通过内核模块按fd强制tcp的quickack方法

一、背景

tcp的quickack功能是为了让ack迅速回发，快速响应，减少网络通讯时延，属于一个优化项，但是tcp的quickack是有配额限制的，配置是16个quick，也就是短时间内quickack了16次以后，这个配额为0了以后，就算当前是quickack模式（非pingpong模式），系统仍然可能不进行quickack发送。为什么用"可能"呢？因为还有一些其他的条件检查，这些条件是或的关系，只要有一条满足了，系统就会quickack，其中，最常满足的是通过设置路由规则的quickack，让相关的tcp连接的fd都能强制进行quickack，就算quickack配额已经为0了，也并不影响quickack的发送。

在下面第二章里，我们贴出了实现的源码，并进行成果展示，同时也会给出路由方式进行设置的方式和结果展示，在第三章里，会讲解第二章里的源码的实现原理。

在后面的博客里，我们会进行setsockopt的定制，增加一个force quickack的选项，避免反复的通过setsockopt来触发增加quickack配额。

另外，如果需求可以通过增加路由规则来满足那也没必要这么麻烦，直接参考 2.4 一节里的方法即可。通过增加路由规则的方式的不足在于它不能按照fd来进行指定fd的quickack强制，要强制就对所有适用于增加的这条路由规则的tcp连接一起起效了。

二、源码及成果展示

2.1 通过内核模块方式捕获setsockopt系统调用进行quickack配额填充的源码

源码如下：

#include <linux/module.h>
#include <linux/capability.h>
#include <linux/sched.h>
#include <linux/uaccess.h>
#include <linux/proc_fs.h>
#include <linux/ctype.h>
#include <linux/seq_file.h>
#include <linux/poll.h>
#include <linux/types.h>
#include <linux/ioctl.h>
#include <linux/errno.h>
#include <linux/stddef.h>
#include <linux/lockdep.h>
#include <linux/kthread.h>
#include <linux/sched.h>
#include <linux/delay.h>
#include <linux/wait.h>
#include <linux/init.h>
#include <asm/atomic.h>
#include <trace/events/workqueue.h>
#include <linux/sched/clock.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/interrupt.h>
#include <linux/tracepoint.h>
#include <trace/events/osmonitor.h>
#include <trace/events/sched.h>
#include <trace/events/irq.h>
#include <trace/events/kmem.h>
#include <linux/ptrace.h>
#include <linux/uaccess.h>
#include <asm/processor.h>
#include <linux/sched/task_stack.h>
#include <linux/nmi.h>
#include <asm/apic.h>
#include <linux/version.h>
#include <linux/sched/mm.h>
#include <asm/irq_regs.h>
#include <linux/kallsyms.h>
#include <linux/kprobes.h>
#include <linux/stop_machine.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("zhaoxin");
MODULE_DESCRIPTION("Module for debug quickack.");
MODULE_VERSION("1.0");



struct kern_tracepoint {
    void *callback;
    struct tracepoint *ptr;
    bool bregister;
};
static void clear_kern_tracepoint(struct kern_tracepoint *tp)
{
    if (tp->bregister) {
        tracepoint_probe_unregister(tp->ptr, tp->callback, NULL);
    }
}

#define INIT_KERN_TRACEPOINT(tracepoint_name) \
    static struct kern_tracepoint mykern_##tracepoint_name = {.callback = NULL, .ptr = NULL, .bregister = false};


#define TRACEPOINT_CHECK_AND_SET(tracepoint_name)                                             \
    static void tracepoint_name##_tracepoint_check_and_set(struct tracepoint *tp, void *priv) \
    {                                                                                \
        if (!strcmp(#tracepoint_name, tp->name))                                     \
        {                                                                            \
            ((struct kern_tracepoint *)priv)->ptr = tp;                          \
            return;                                                                  \
        }                                                                            \
    }

//INIT_KERN_TRACEPOINT(sched_switch)
//TRACEPOINT_CHECK_AND_SET(sched_switch)
//INIT_KERN_TRACEPOINT(sched_waking)
//TRACEPOINT_CHECK_AND_SET(sched_waking)


typedef unsigned long (*kallsyms_lookup_name_func)(const char *name);
kallsyms_lookup_name_func _kallsyms_lookup_name_func;

void* get_func_by_symbol_name_kallsyms_lookup_name(void)
{
    int ret;
    void* pfunc = NULL;
	struct kprobe kp;
	memset(&kp, 0, sizeof(kp));
	kp.symbol_name = "kallsyms_lookup_name";
	kp.pre_handler = NULL;
	kp.addr = NULL;	// 作为强调，提示使用symbol_name
	ret = register_kprobe(&kp);
	if (ret < 0) {
		printk("register_kprobe fail!\n");
		return NULL;
	}
	printk("register_kprobe succeed!\n");
    pfunc = (void*)kp.addr;
	unregister_kprobe(&kp);
    return pfunc;
}

void* get_func_by_symbol_name(const char* i_symbol)
{
    if (_kallsyms_lookup_name_func == NULL) {
        return NULL;
    }
    return _kallsyms_lookup_name_func(i_symbol);
}

#include <uapi/linux/rtnetlink.h>
#include <net/sock.h>
#include <net/inet_connection_sock.h>


#include <linux/netdevice.h>
#include <linux/inetdevice.h>
#include <linux/ip.h>
#include <net/dst.h>
#include <net/route.h>
#include <net/tcp.h>
#include <linux/inet.h>
#include <linux/sockptr.h>

// void print_dst_entry(struct dst_entry *dst) {
//     struct rtable *rt = (struct rtable *)dst;
//     struct in_device *in_dev;
 
//     if (!dst)
//         return;
 
//     in_dev = __in_dev_get_rcu(rt->u.dst.dev);
 
//     printk(KERN_INFO "Dst Entry Info:\n");
//     printk(KERN_INFO "  Input Device: %s\n", rt->u.dst.dev->name);
//     printk(KERN_INFO "  Output Device: %s\n", rt->u.dst.dev->name);
//     if (in_dev) {
//         printk(KERN_INFO "  In Device MTU: %d\n", in_dev->mtu);
//         printk(KERN_INFO "  In Device Output MTU: %d\n", in_dev->output_mtu);
//     }
//     printk(KERN_INFO "  Expires: %ld\n", dst->expires);
//     printk(KERN_INFO "  Flags: 0x%lx\n", dst->flags);
//     printk(KERN_INFO "  Last Use: %lu\n", dst->lastuse);
//     printk(KERN_INFO "  Obsolete: %lu\n", dst->obsolete);
//     printk(KERN_INFO "  Hash Chain: %p\n", dst->dn.next);
//     printk(KERN_INFO "  Input Hash: 0x%lx\n", dst->hash);
//     printk(KERN_INFO "  Output Hash: 0x%lx\n", dst->child_mask);
//     printk(KERN_INFO "  Reference Count: %d\n", atomic_read(&dst->__refcnt));
//     printk(KERN_INFO "  Use Count: %d\n", dst->use);
//     printk(KERN_INFO "  Wireless Use Count: %d\n", dst->wireless_ref);
//     printk(KERN_INFO "  Last Metric Update: %lu\n", dst->last_metric_update);
//     printk(KERN_INFO "  Protocol Specific Data: %p\n", dst->input);
//     printk(KERN_INFO "  Optimistic ACK Prediction: %d\n", tcp_hdr(rt->u.dst.xfrm)->ack_seq - 1);
// }

void print_rtable_info(struct rtable *rt) {
    if (!rt) {
        printk(KERN_ERR "rtable is NULL\n");
        return;
    }

    // 打印 rtable 的基本信息
    printk(KERN_INFO "Route Entry Information:\n");
    //printk(KERN_INFO "Destination Address: %pI4\n", &rt->dst.dest.addr);
    printk(KERN_INFO "Gateway: %pI4\n", &rt->rt_gw4);
    printk(KERN_INFO "Flags: 0x%x\n", rt->rt_flags);
    printk(KERN_INFO "Type: %u\n", rt->rt_type);
    printk(KERN_INFO "Input Interface: %d\n", rt->rt_iif);
    printk(KERN_INFO "Uses Gateway: %u\n", rt->rt_uses_gateway);
    printk(KERN_INFO "MTU: %u\n", rt->rt_pmtu);
    printk(KERN_INFO "MTU Locked: %u\n", rt->rt_mtu_locked);
    printk(KERN_INFO "Generation ID: %d\n", rt->rt_genid);
}

// void print_dst_entry_info(struct dst_entry *dst) {
//     if (!dst) {
//         printk(KERN_ERR "dst_entry is NULL\n");
//         return;
//     }

//     // 打印 dst_entry 的基本信息
//     printk(KERN_INFO "Destination Address: %pI4\n", &dst->dest.addr);
//     printk(KERN_INFO "Flags: 0x%x\n", dst->flags);
//     //printk(KERN_INFO "Reference Count: %d\n", atomic_read(&dst->refcnt));
    
//     // 如果是 IPv4 路由表
//     // {
//     //     struct rtable *rt = (struct rtable *)dst; // 转换为 rtable
//     //     printk(KERN_INFO "Gateway: %pI4\n", &rt->rt_gw);
//     //     printk(KERN_INFO "Interface: %s\n", rt->dev->name);
//     //     printk(KERN_INFO "Metric: %u\n", rt->rt_metric);
//     // }

//     // 可以添加更多字段的信息
// }

int _notquickmodecount = 0;

static bool tcp_in_quickack_mode(struct sock *sk)
{
    struct inet_sock *inet = inet_sk(sk);
	const struct inet_connection_sock *icsk = inet_csk(sk);
	const struct dst_entry *dst = __sk_dst_get(sk);
    u32 dst_metric_ret = 0;
    u32 dst_v = 0;
    bool ret;

    if (dst) {
        dst_v = 1;
        dst_metric_ret = dst_metric(dst, RTAX_QUICKACK);
    }

	ret = (dst && dst_metric(dst, RTAX_QUICKACK)) ||
		(icsk->icsk_ack.quick && !inet_csk_in_pingpong_mode(sk));
    if (ret) {
        printk("pid[%d]quick mode[%u], dst[%u]dst_metric_ret[%u]icsk->icsk_ack.quick[%u]quickmode[%u]src[%pI4]dst[%pI4]src_port[%u]dst_port[%u]\n", 
            current->pid, ret ? 1 : 0,
            dst_v, dst_metric_ret, (u32)icsk->icsk_ack.quick, (!inet_csk_in_pingpong_mode(sk))?1:0,
            &sk->sk_rcv_saddr, &sk->sk_daddr, ntohs(inet->inet_sport), ntohs(inet->inet_dport));
    }
    else {
        if (_notquickmodecount > 10) {

        }
        else {
            _notquickmodecount++;
            printk("pid[%d]quick mode[%u], dst[%u]dst_metric_ret[%u]icsk->icsk_ack.quick[%u]quickmode[%u]src[%pI4]dst[%pI4]src_port[%u]dst_port[%u]\n", 
                current->pid, ret ? 1 : 0,
                dst_v, dst_metric_ret, (u32)icsk->icsk_ack.quick, (!inet_csk_in_pingpong_mode(sk))?1:0,
                &sk->sk_rcv_saddr, &sk->sk_daddr, ntohs(inet->inet_sport), ntohs(inet->inet_dport));
        }
    }
    return ret;
}

static int haslog = 0;

struct kprobe _kp;
struct kprobe _kp1;
 
// __tcp_ack_snd_check
int kprobecb_tcp_ack_snd_check(struct kprobe* i_k, struct pt_regs* i_p)
{
    //printk("kprobecb_tcp_ack_snd_check enter");
    //unsigned long arg1 = regs->di;
    struct sock *sk = (struct sock *) i_p->di;
    struct inet_sock *inet = inet_sk(sk);
    __be32 target_ip, dst_ip;
    target_ip = in_aton("10.100.130.87");
    dst_ip = in_aton("10.100.130.103");
    if (sk->sk_rcv_saddr == target_ip 
        && sk->sk_daddr == dst_ip) {
        if (tcp_in_quickack_mode(sk)) {
            //haslog = 1;
            //printk("quick mode, src[%pI4]dst[%pI4]src_port[%u]dst_port[%u]\n", &sk->sk_rcv_saddr, &sk->sk_daddr, ntohs(inet->inet_sport), ntohs(inet->inet_dport));
            //printk(KERN_INFO "Destination IP: %pI4\n", &sk->sk_daddr);
            //print_rtable_info((struct rtable *)__sk_dst_get(sk));
        }
        else {
            //printk("NOT quick mode, src[%pI4]dst[%pI4]src_port[%u]dst_port[%u]\n", &sk->sk_rcv_saddr, &sk->sk_daddr, ntohs(inet->inet_sport), ntohs(inet->inet_dport));
            //printk("NOT quick mode\n");
        }
    }
    return 0;
}

#define MY_KERNEL_KLOG_INFO_HEXDUMP( addr, size) \
    do {    \
        print_hex_dump(KERN_INFO, "hex_dump:", DUMP_PREFIX_NONE, 32, 4, addr, size, true);  \
    } while (0)

static void tcp_quickack_config(struct sock *sk)
{
	struct inet_connection_sock *icsk = inet_csk(sk);
    
    if (icsk->icsk_ack.quick != 16) {
        icsk->icsk_ack.quick = 16;
        printk("pid[%d]set quick = 16\n", current->pid);
        
    }
	// unsigned int quickacks = tcp_sk(sk)->rcv_wnd / (2 * icsk->icsk_ack.rcv_mss);

	// if (quickacks == 0)
	// 	quickacks = 2;
	// quickacks = min(quickacks, max_quickacks);
	// if (quickacks > icsk->icsk_ack.quick)
	// 	icsk->icsk_ack.quick = quickacks;
}

#if 0
void kprobecb_tcp_sock_set_quickack(struct kprobe* i_k, struct pt_regs* i_p,
    unsigned long i_flags)
{
    struct sock *sk = (struct sock*) i_p->di;
    int* pval = i_p->r10;
    int val;
    int len = i_p->r8;
    //tcp_enter_quickack_mode(sk, 16);
    //printk("val=%d\n", val);
    printk("len[%d]\n", len);
    if (len == 4) {
        val = *pval;
        if ((val & 1) && val != 1) {
            printk("111 val=%d\n", val);
            //tcp_enter_quickack_mode(sk, 16);
            //tcp_incr_quickack(sk, 16u);
        }
    }

}
#endif

static int handler_pre(struct pt_regs *regs) {
    // 打印 pt_regs 中的内容
    printk(KERN_INFO "pt_regs contents:\n");
    printk(KERN_INFO "RIP: 0x%lx\n", regs->ip);
    printk(KERN_INFO "RSP: 0x%lx\n", regs->sp);
    printk(KERN_INFO "RBP: 0x%lx\n", regs->bp);
    printk(KERN_INFO "RAX: 0x%lx\n", regs->ax);
    printk(KERN_INFO "RBX: 0x%lx\n", regs->bx);
    printk(KERN_INFO "RCX: 0x%lx\n", regs->cx);
    printk(KERN_INFO "RDX: 0x%lx\n", regs->dx);
    printk(KERN_INFO "RSI: 0x%lx\n", regs->si);
    printk(KERN_INFO "RDI: 0x%lx\n", regs->di);
    printk(KERN_INFO "R8: 0x%lx\n", regs->r8);
    printk(KERN_INFO "R9: 0x%lx\n", regs->r9);
    printk(KERN_INFO "R10: 0x%lx\n", regs->r10);
    printk(KERN_INFO "R11: 0x%lx\n", regs->r11);
    printk(KERN_INFO "R12: 0x%lx\n", regs->r12);
    printk(KERN_INFO "R13: 0x%lx\n", regs->r13);
    printk(KERN_INFO "R14: 0x%lx\n", regs->r14);
    printk(KERN_INFO "R15: 0x%lx\n", regs->r15);

    return 0; // 继续执行被探测的函数
}

int kprobecb_tcp_sock_set_quickack(struct kprobe* i_k, struct pt_regs* i_p)
{
    struct sock *sk = (struct sock*) i_p->di;
    struct inet_connection_sock *icsk = inet_csk(sk);
    //sockptr_t pval = (sockptr_t)i_p->cx;
    int val;
    int len = i_p->r9;

    //MY_KERNEL_KLOG_INFO_HEXDUMP(icsk->icsk_ca_priv, 104);
    //tcp_enter_quickack_mode(sk, 16);
    //printk("val=%d\n", val);
    // printk("len[%d][0x%llx][0x%llx][0x%llx][0x%llx][0x%llx]\n", len,
    //     i_p->di, i_p->si, i_p->dx, i_p->cx, i_p->r9);
    
    if (len == 4) {
        copy_from_user(&val, i_p->cx, 4);
        //memcpy(&val, i_p->cx, 4);
        // if (copy_from_sockptr(&val, pval, sizeof(val))) {
        //     return 0;
        // }
        if (i_p->dx == 12) {
            if ((val & 1) && val != 1) {
                //printk("111 val=%d\n", val);
                //handler_pre(i_p);
                //tcp_enter_quickack_mode(sk, 16);
                tcp_quickack_config(sk);
                
            }
        }
        
    }
    return 0;
}
 
int kprobe_register_func_tcp_ack_snd_check(void)
{
    int ret;
    memset(&_kp, 0, sizeof(_kp));
    _kp.symbol_name = "__tcp_ack_snd_check";
    _kp.pre_handler = kprobecb_tcp_ack_snd_check;
    ret = register_kprobe(&_kp);
	if (ret < 0) {
		printk("register_kprobe fail!\n");
		return -1;
	}
    return 0;
}

int kprobe_register_func_tcp_sock_set_quickack(void)
{
    int ret;
    memset(&_kp1, 0, sizeof(_kp1));
    _kp1.symbol_name = "tcp_setsockopt";
    _kp1.pre_handler = kprobecb_tcp_sock_set_quickack;
    ret = register_kprobe(&_kp1);
	if (ret < 0) {
		printk("register_kprobe fail!\n");
		return -1;
	}
    return 0;
}
 
void kprobe_unregister_func_tcp_ack_snd_check(void)
{
    unregister_kprobe(&_kp);
}

void kprobe_unregister_func_tcp_sock_set_quickack(void)
{
    unregister_kprobe(&_kp1);
}


static int __init testquickack_init(void)
{
    _kallsyms_lookup_name_func = get_func_by_symbol_name_kallsyms_lookup_name();

    kprobe_register_func_tcp_ack_snd_check();
    kprobe_register_func_tcp_sock_set_quickack();
    
#if 0
    mykern_sched_waking.callback = cb_sched_waking;
    for_each_kernel_tracepoint(sched_waking_tracepoint_check_and_set, &mykern_sched_waking);
    if (!mykern_sched_waking.ptr) {
        printk(KERN_ERR "mykern_sched_waking register failed!\n");
        return -1;
    }
    else {
        printk(KERN_INFO "mykern_sched_waking register succeeded!\n");
    }
    tracepoint_probe_register(mykern_sched_waking.ptr, mykern_sched_waking.callback, NULL);
    mykern_sched_waking.bregister = 1;
#endif

    return 0;
}

static void __exit testquickack_exit(void)
{
    //clear_kern_tracepoint(&mykern_sched_waking);

    //tracepoint_synchronize_unregister();
    
    kprobe_unregister_func_tcp_ack_snd_check();
    kprobe_unregister_func_tcp_sock_set_quickack();
}

module_init(testquickack_init);
module_exit(testquickack_exit);

2.2 服务端和客户端的源码

server端的代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/tcp.h>

#define PORT 80
#define BUFFER_SIZE 1024

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    char buffer[BUFFER_SIZE] = {0};

    // 创建 socket
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("Socket failed");
        exit(EXIT_FAILURE);
    }

    {
        // int optval = 1; // 启用 QUICKACK 选项
        // socklen_t optlen = sizeof(optval);
        // // 设置 TCP_QUICKACK 选项
        // if (setsockopt(server_fd, IPPROTO_TCP, TCP_QUICKACK, &optval, optlen) < 0) {
        //     perror("setsockopt");
        //     close(server_fd);
        //     exit(EXIT_FAILURE);
        // }
    }

    // 设置地址结构
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = inet_addr("10.100.130.87");
    address.sin_port = htons(PORT);

    // 绑定 socket
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("Bind failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // 开始监听
    if (listen(server_fd, 3) < 0) {
        perror("Listen failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    printf("Server is listening on %s:%d\n", "10.100.130.87", PORT);

    // 循环接受信息
    while (1) {
        if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
            perror("Accept failed");
            continue;
        }

        printf("Connected to client\n");

        // 接受信息
        while (1) {

            // {
            //     int optval = 1; // 启用 QUICKACK 选项
            //     socklen_t optlen = sizeof(optval);
            //     // 设置 TCP_QUICKACK 选项
            //     if (setsockopt(server_fd, IPPROTO_TCP, TCP_NODELAY, &optval, optlen) < 0) {
            //         perror("setsockopt");
            //         close(server_fd);
            //         exit(EXIT_FAILURE);
            //     }
            // }
            {
                int optval = 3; // 启用 QUICKACK 选项
                socklen_t optlen = sizeof(optval);
                // 设置 TCP_QUICKACK 选项
                if (setsockopt(new_socket, IPPROTO_TCP, TCP_QUICKACK, &optval, optlen) < 0) {
                    perror("setsockopt");
                    close(new_socket);
                    exit(EXIT_FAILURE);
                }
            }
            int valread = read(new_socket, buffer, BUFFER_SIZE);
            if (valread > 0) {
                buffer[valread] = '\0';  // 确保字符串以 null 结束
                printf("Received: %s\n", buffer);
            } else {
                break; // 客户端关闭连接
            }
        }

        printf("Client disconnected\n");
        close(new_socket);
    }

    close(server_fd);
    return 0;
}

client端的代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 80
#define BUFFER_SIZE 1024

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char *message = "Hello from client";

    // 创建 socket
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        printf("\n Socket creation error \n");
        return -1;
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);

    // 转换 IPv4 和 IPv6 地址从文本到二进制
    if (inet_pton(AF_INET, "10.100.130.87", &serv_addr.sin_addr) <= 0) {
        printf("\nInvalid address/ Address not supported \n");
        return -1;
    }

    // 连接到服务器
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        printf("\nConnection Failed \n");
        return -1;
    }

    // 循环发送信息
    while (1) {
        send(sock, message, strlen(message), 0);
        printf("Message sent: %s\n", message);
        //sleep(1); // 每秒发送一次
        usleep(1);
    }

    close(sock);
    return 0;
}

2.3 成果展示

先在server的机器上，insmod 2.1一节里的源码编出的ko后，运行server程序，然后，在client的机器上运行client程序，注意上面 2.1 一节和 2.2 一节里的ip地址需要根据实际情况来改变。

server刚运行起来以后的打印：

运行client后，client的打印：

server这边的打印：

再看dmesg里的打印：

可以从上图中看到，server这边每次调用recv接受client这边发来的消息前，会进行依次setsockopt的系统调用从而触发了dmesg里的kprobe的逻辑，对应的内核的代码逻辑是：

这样，在判断是否进行quickack时，就会得到quickack的mode是1的结果，因为quickack被我们反复的设置回16了：

2.4 通过路由配置的方法和成果展示

首先强调一下，通过增加路由规则的方式的不足在于它不能按照fd来进行指定fd的quickack强制，要强制就对所有适用于增加的这条路由规则的tcp连接一起起效了。

反过来说，如果不需要细粒度的针对路由规则适用的tcp连接里部分使用quickack部分不适用quickack进行针对性配置的话，那么用本节的方法也是更加规范和更加通用。

适用本节的方法，还需要考虑网卡link down/up的变化的情况，link up以后，需要重新设置路由规则，避免路由规则丢失导致不能quickack。

2.4.1 路由配置方式

根据当前测试环境的网络，如下方式配置：

ip route add 10.100.130.0/24 quickack 1 dev enp0s31f6

设置后可以通过ip -d route来查看是否设置进去了，如下图，成功设置了quickack：

2.4.2 路由配置后可以看到quickack的检查一直都是1的

在做验证前，把服务端代码里的setsockopt的逻辑去掉：

重新启动server，并启动client后，可以如下图的dmesg里的打印看到，quickack mode一直是检查是1的：

三、实现原理

这一章我们讲的是 2.1 一节里展示的源码里的实现原理。

事实上，它是用kprobe方式来hook setsockopt系统调用，过滤出如果设置的是TCP_QUICKACK的type的话，根据设置指定一个一般不会去设置的值，去做额外的逻辑，补充quickack配额，但是这是需要客户端不断地进行setsockopt系统调用的。

下面的实现的原理介绍省去了之前的博客多次提到的tracepoint及kprobe获取函数指针的原理说明，有关这两个话题，参考之前的 内核tracepoint的注册回调及添加的方法_tracepoint 自定义回调-CSDN博客 和 内核模块里访问struct rq及获取rq_clock_task时间的方法-CSDN博客 博客。

3.1 内核里是通过__tcp_ack_snd_check函数来判断是否需要quickack

内核里判断tcp是否需要quickack，是在tcp_input.c里的__tcp_ack_snd_check函数里，如下图：

上图里的关键的函数是tcp_in_quickack_mode这个函数：

这个函数有两种情况回返回进行quickack：

1）当前的sock连接有使能quickack的路由规则与之对应，RTAX_QUICKACK这个标志位，我们可以通过strace来跟踪 2.4 一节里介绍的路由设置命令，可以跟踪到这个标志位设置。

2）当前的sock连接是设置的quickack模式的且quick计数不是0，实测发现，目前默认是适用quickack模式的，并不需要额外去做这样的设置，pingpong mode是false也就是使用quickack mode。除了使用quickack模式，还需要满足quick计数不是0的条件，而quick计数会在每次recv收后减一，减到0以后，上图中的(icsk->icsk_ack.quick && !inet_csk_in_pingpong_mode(sk))就是0了

另外，需要说明的是，为什么我们不直接kprobe tcp_in_quickack_mode这个函数，而是kprobe __tcp_ack_snd_check函数，是因为tcp_in_quickack_mode这个函数在kallsyms里是没有的：

而__tcp_ack_snd_check在kallsyms里是有的：

3.2 通过kprobe捕获tcp_setsockopt，进行quick计数的特殊处理

用户态是通过如下方式进行的设置：

这样，内核态在捕获tcp_setsockopt时，可以根据传下来的数值来进行特殊处理，一般来说，我们设置quickack的on/off时，就传0或者1的，我们设置3就是为了区分这种常规的设置，这样我们可以发现是我们的特殊设置，如下逻辑就可以判断出来（另外，下图中的i_p-dx == 12的12表示的是TCP_QUICKACK）：

要注意，内核里是默认的以最后一个bit来判断是否使用quickack模式的：

所以，我们特殊的设置值也遵守这个基本规则，最后一个bit仍然是1，让bit1以上部分非0，来做特殊处理的判断条件。

上面逻辑里如何通过pt_regs拿到各个入参，有两个注意事项，我们会择机在后面的博客里详细展开：

1）当入参的大小大于了64bit后，要根据情况，后移传递参数用的寄存器，为了强调，我们在后面的博客里展开

2）在使用用户态数据时，需要考虑用户态的数据可能还没有缺页异常（还未映射），在内核态里直接使用（比如用memcpy）的话，就会出现内核态错误，使用copy_from_user可以避免这样的问题，详细原因见后面的博客