kk Blog —— 通用基础


date [-d @int|str] [+%s|"+%F %T"]
netstat -ltunp

MPTCP 使用

编译

https://github.com/abcdxyzk/mptcp-v0.95

https://github.com/abcdxyzk/ubuntu-mptcp-v0.95

.config 配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

diff --git a/.config b/.config
index cf146c1c..f5be3370 100644
--- a/.config
+++ b/.config
@@ -1054,6 +1054,11 @@ CONFIG_TCP_CONG_ILLINOIS=m
 CONFIG_TCP_CONG_DCTCP=m
 CONFIG_TCP_CONG_CDG=m
 CONFIG_TCP_CONG_BBR=m
+CONFIG_TCP_CONG_LIA=m
+CONFIG_TCP_CONG_OLIA=m
+CONFIG_TCP_CONG_WVEGAS=m
+CONFIG_TCP_CONG_BALIA=m
+# CONFIG_TCP_CONG_MCTCPDESYNC is not set
 CONFIG_DEFAULT_CUBIC=y
 # CONFIG_DEFAULT_RENO is not set
 CONFIG_DEFAULT_TCP_CONG="cubic"
@@ -1090,6 +1095,21 @@ CONFIG_IPV6_PIMSM_V2=y
 CONFIG_IPV6_SEG6_LWTUNNEL=y
 CONFIG_IPV6_SEG6_HMAC=y
 CONFIG_NETLABEL=y
+CONFIG_MPTCP=y
+CONFIG_MPTCP_PM_ADVANCED=y
+CONFIG_MPTCP_FULLMESH=y
+CONFIG_MPTCP_NDIFFPORTS=m
+CONFIG_MPTCP_BINDER=m
+# CONFIG_MPTCP_NETLINK is not set
+CONFIG_DEFAULT_FULLMESH=y
+# CONFIG_DEFAULT_DUMMY is not set
+CONFIG_DEFAULT_MPTCP_PM="fullmesh"
+CONFIG_MPTCP_SCHED_ADVANCED=y
+# CONFIG_MPTCP_BLEST is not set
+CONFIG_MPTCP_ROUNDROBIN=m
+CONFIG_MPTCP_REDUNDANT=m
+CONFIG_DEFAULT_SCHEDULER=y
+CONFIG_DEFAULT_MPTCP_SCHED="default"
 CONFIG_NETWORK_SECMARK=y
 CONFIG_NET_PTP_CLASSIFY=y
 CONFIG_NETWORK_PHY_TIMESTAMPING=y

https://www.cnblogs.com/fenglt/p/8570343.html

路由配置

enp0s9: 192.168.2.5 gw 192.168.2.4

enp0s10: 192.168.3.5 gw 192.168.3.4

1
2
3
4
5
6
7

ip rule add table 1 from 192.168.2.5
ip route add 192.168.2.0/24 dev enp0s9 scope link table 1
ip route add default via 192.168.2.4 dev enp0s9 table 1

ip rule add table 2 from 192.168.3.5
ip route add 192.168.3.0/24 dev enp0s10 scope link table 2
ip route add default via 192.168.3.4 dev enp0s10 table 2

fullmesh, ndiffports, binder, netlink

工具

sudo apt-get install bison flex

https://github.com/abcdxyzk/iproute-mptcp

./configure

make

./ip/ip link set dev enp0s3 multipath off/on/backup

off命令是在MPTCP层面上的，并不是完全关闭该接口，而是控制MPTCP不去试图使用该网卡，换言之，当路由表指向该接口时，该接口还是会被使用的。

backup命令就是将该接口设置为backup模式，并且会通过PRIO option通知对方，两边会标记low_prio、rcv_low_prio。但目前所有pm都没有用到low_prio。

https://www.cnblogs.com/zhuting/p/5828988.html

http://multipath-tcp.org/pmwiki.php/Users/ConfigureMPTCP

参数

net.mptcp.mptcp_enabled

顾名思义，该变量控制MPTCP开关，实现MPTCP与传统TCP之间的切换。变量值为0或1（默认为1）。

net.mptcp.mptcp_checksum

该变量控制MPTCP传输层中数据序列号校验和（DSS-checksum）的开关，DSS-checksum主要和传输的可靠性相关，只要通信对端中有一端开启，就会执行。变量值为0或1（默认为1）。

net.mptcp.mptcp_syn_retries

设置SYN的重传次数。SYN里包含了MP_CAPABLE-option字段，通过该控制变量，SYN将不会包含MP_CAPABLE-option字段，这是为了处理会丢弃含有未知TCP选项的SYN的网络中间件。变量默认值为3。

net.mptcp.mptcp_debug

调试MPTCP，控制是否打印debug报告文件。

net.mptcp.mptcp_path_manager

MPTCP路径管理，有四个不同的配置值，分别是 default/fullmesh/ndiffports/binder。default/ndiffports/fullmesh分别选择单路、多路或者全路进行传输。其中单路是指跟传统TCP状态一样还是用单一的TCP子流进行传输，多路是当前所有TCP子流中用户选择x条子流数进行传输，全路是指将当前所有可用的TCP子流应用到网络传输中。而binder参考了文献 Binder: a system to aggregate multiple internet gateways in community networks。

fix: default=fullmesh

net.mptcp.mptcp_scheduler

MPTCP子流调度策略，有default/roundrobin两个选项。default优先选择RTT较低的子流直到拥塞窗口满，roundrobin采用轮询策略。

https://www.cnblogs.com/lxgeek/p/4187164.html

MPTCP 理解

MPTCP允许在一条TCP链路中建立多个子通道。当一条通道按照三次握手的方式建立起来后，可以按照三次握手的 方式建立其他的子通道，这些通道以三次握手建立连接和四次握手解除连接。这些通道都会绑定于MPTCP session， 发送端的数据可以选择其中一条通道进行传输。

MPTCP的设计遵守以下两个原则：

1.应用程序的兼容性，应用程序只要可以运行在TCP环境下，就可以在没有任何修改的情况下，运行于MPTCP环境。

2.网络的兼容性，MPTCP兼容其他协议。

MPTCP在协议栈中的位置如下所示：

建立连接过程

如上图所示：MPTCP的第一个子通道的建立遵守TCP的三次握手，唯一的区别是每次发送的 报文段需要添加MP_CAPABLE的的TCP选项和一个安全用途的key。而下图是建立其他的子通道：

如上图所示：第二条子通道的建立依然遵守TCP的三次握手，而TCP选项换成了MP_JOIN。 而token是基于key的一个hash值，rand为一个随机数，而HMAC是基于rand的一个hash值。

数据的发送和接收

MPTCP可以选择多条子通道中任意一条来发送数据。MPTCP如果使用传统的TCP的方式 来发送数据，将会出现一部分包在一条子通道，而另一部分包在另外一条子通道。这样的话，防火墙等 中间设备将会收到TCP的序号跳跃的包，因此将会发生丢包等异常情况。为了解决这个问题，MPTCP通过 增加DSN(data sequence number)来管理包的发送，DSN统计总的报文段序号，而每个子通道中的 序号始终是连续。

MPTCP的接收包过程分为两个阶段：第一、每个子通道依据自身序号来重组报文段；第二、MPTCP 的控制模块依据DSN对所有子通道的报文段进行重组。

拥塞控制

MPTCP中拥塞控制的设计需遵守以下两个原则：

第一：MPTCP和传统TCP应该拥有相同的吞吐量，而不是MPTCP中每一条子通道和传统TCP具有相同的吞吐量。

第二：MPTCP在选择子通道的时候应该选择拥塞情况更好的子通道。

MPTCP的实现

MPTCP的实现主要分为三部分：

master subsocket

Multi-path control bock(mpcb)

slave subsocket

master subsock是一个标准的sock结构体用于TCP通信。mpcb提供开启或关闭子通道、 选择发送数据的子通道以及重组报文段的功能。slave subsocket对应用程序并不可见，他们 都是被mpcb管理并用于发送数据。

reuseport使用

http://www.it165.net/os/html/201605/17066.html

Q&A

Q1：什么是reuseport？

A1：reuseport是一种套接字复用机制，它允许你将多个套接字bind在同一个IP地址/端口对上，这样一来，就可以建立多个服务来接受到同一个端口的连接。

Q2：当来了一个连接时，系统怎么决定到底是哪个套接字来处理它？

A2：对于不同的内核，处理机制是不一样的，总的说来，reuseport分为两种模式，即热备份模式和负载均衡模式，在早期的内核版本中，即便是加入对reuseport选项的支持，也仅仅为热备份模式，而在3.9内核之后，则全部改为了负载均衡模式，两种模式没有共存

Q3：什么是热备份模式和负载均衡模式呢？

A3： 热备份模式：即你创建了N个reuseport的套接字，然而工作的只有一个，其它的作为备份，只有当前一个套接字不再可用的时候，才会由后一个来取代，其投入工作的顺序取决于实现。

负载均衡模式：即你创建的所有N个reuseport的套接字均可以同时工作，当连接到来的时候，系统会取一个套接字来处理它。这样就可以达到负载均衡的目的，降低某一个服务的压力。

Q4：到底怎么取套接字呢？

A4：这个对于热备份模式和负载均衡模式是不同的。

热备份模式：一般而言，会将所有的reuseport同一个IP地址/端口的套接字挂在一个链表上，取第一个即可，如果该套接字挂了，它会被从链表删除，然后第二个便会成为第一个。

负载均衡模式：和热备份模式一样，所有reuseport同一个IP地址/端口的套接字会挂在一个链表上，你也可以认为是一个数组，这样会更加方便，当有连接到来时，用数据包的源IP/源端口作为一个HASH函数的输入，将结果对reuseport套接字数量取模，得到一个索引，该索引指示的数组位置对应的套接字便是工作套接字。

关于REUSEPORT的实现

Linux 4.5/4.6所谓的对reuseport的优化主要体现在查询速度上，在优化前，在HASH冲突链表上遍历所有的套接字之后才能知道到底取哪个(基于一种冒泡的score打分机制，不完成一轮冒泡遍历，不能确定谁的score最高)，之所以如此低效是因为内核将reuseport的所有套接字和其它套接字混合在了一起，查找是平坦的，正常的做法应该是将它们分为一个组，进行分层查找，先找到这个组(这个很容易)，然后再在组中找具体的套接字。Linux 4.5针对UDP做了上述优化，而Linux 4.6则将这个优化引入到了TCP。

设想系统中一共有10000个套接字被HASH到同一个冲突链表，其中9950个是reuseport的同一组套接字，如果按照老的算法，需要遍历10000个套接字，如果使用基于分组的算法，最多只需要遍历51个套接字即可，找到那个组之后，一步HASH就可以找到目标套接字的索引！

Linux 4.5之前的reuseport查找实现(4.3内核)

以下是未优化前的Linux 4.3内核的实现，可见是多么地不直观。它采用了遍历HASH冲突链表的方式进行reuseport套接字的精确定位：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

result = NULL;
badness = 0;
udp_portaddr_for_each_entry_rcu(sk, node, &hslot2->head) {
	score = compute_score2(sk, net, saddr, sport, daddr, hnum, dif);
	if (score > badness) { // 冒泡排序
		// 找到了更加合适的socket，需要重新hash
		result = sk;
		badness = score;
		reuseport = sk->sk_reuseport;
		if (reuseport) {
			hash = udp_ehashfn(net, daddr, hnum, saddr, sport);
			matches = 1;
		}
	} else if (score == badness && reuseport) { // reuseport套接字散列定位
		// 找到了同样reuseport的socket，进行定位
		matches++;
		if (reciprocal_scale(hash, matches) == 0)
			result = sk;
		hash = next_pseudo_random32(hash);
	}
}

之所以要遍历是因为所有的reuseport套接字和其它的套接字都被平坦地插入到同一个表中，事先并不知道有多少组reuseport套接字以及每一组中有多少个套接字

Linux 4.5(针对UDP)/4.6(针对TCP)的reuseport查找实现

我们来看看在4.5和4.6内核中对于reuseport的查找增加了一些什么神奇的新东西：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

result = NULL;
badness = 0;
udp_portaddr_for_each_entry_rcu(sk, node, &hslot2->head) {
	score = compute_score2(sk, net, saddr, sport, daddr, hnum, dif);
	if (score > badness) {
		// 在reuseport情形下，意味着找到了更加合适的socket组，需要重新hash
		result = sk;
		badness = score;
		reuseport = sk->sk_reuseport;
		if (reuseport) {
			hash = udp_ehashfn(net, daddr, hnum, saddr, sport);
			if (select_ok) {
				struct sock *sk2;
				// 找到了一个组，接着进行组内hash。
				sk2 = reuseport_select_sock(sk, hash, skb, sizeof(struct udphdr));
				if (sk2) {
					result = sk2;
					select_ok = false;
					goto found;
				}
			}
			matches = 1;
		}
	} else if (score == badness && reuseport) {
		// 这个else if分支的期待是，在分层查找不适用的时候，寻找更加匹配的reuseport组，注意4.5/4.6以后直接寻找的是一个reuseport组。
		// 在某种意义上，这回退到了4.5之前的算法。
		matches++;
		if (reciprocal_scale(hash, matches) == 0)
			result = sk;
		hash = next_pseudo_random32(hash);
	}
}

我们着重看一下reuseport_select_sock，这个函数是第二层组内查找的关键，其实不应该叫做查找，而应该叫做定位更加合适：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

struct sock *reuseport_select_sock(struct sock *sk, u32 hash, struct sk_buff *skb, int hdr_len)
{
	...
	prog = rcu_dereference(reuse->prog);
	socks = READ_ONCE(reuse->num_socks);
	if (likely(socks)) {
		/* paired with smp_wmb() in reuseport_add_sock() */
		smp_rmb();
 
		if (prog && skb) // 可以用BPF来从用户态注入自己的定位逻辑，更好实现基于策略的负载均衡
			sk2 = run_bpf(reuse, socks, prog, skb, hdr_len);
		else
			// reciprocal_scale简单地将结果限制在了[0,socks)这个区间内
			sk2 = reuse->socks[reciprocal_scale(hash, socks)];
	}
	...
}

reuseport使用

https://www.cnblogs.com/Anker/p/7076537.html

SO_REUSEPORT解决了什么问题

SO_REUSEPORT支持多个进程或者线程绑定到同一端口，提高服务器程序的性能，解决的问题：

允许多个套接字 bind()/listen() 同一个TCP/UDP端口
每一个线程拥有自己的服务器套接字
在服务器套接字上没有了锁的竞争

内核层面实现负载均衡

安全层面，监听同一个端口的套接字只能位于同一个用户下面

其核心的实现主要有三点：

扩展 socket option，增加 SO_REUSEPORT 选项，用来设置 reuseport。

修改 bind 系统调用实现，以便支持可以绑定到相同的 IP 和端口

修改处理新建连接的实现，查找 listener 的时候，能够支持在监听相同 IP 和端口的多个 sock 之间均衡选择。

有了SO_RESUEPORT后，每个进程可以自己创建socket、bind、listen、accept相同的地址和端口，各自是独立平等的。让多进程监听同一个端口，各个进程中accept socket fd不一样，有新连接建立时，内核只会唤醒一个进程来accept，并且保证唤醒的均衡性。

可优化 ？？

在 ___inet_lookup_listener -> compute_score() 中，每个cpu只选特定的sk，这样能减少锁竞争和cache吗 ？？？

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

#define _GNU_SOURCE

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <sys/wait.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <fcntl.h>


#include <sched.h>
#include <pthread.h>

#include <netinet/tcp.h>

#define IP        "192.168.3.6"
#define PORT      80
#define WORKER        8
#define MAXLINE       4096


int worker(int i)
{
	struct sockaddr_in address;
	bzero(&address, sizeof(address));
	address.sin_family = AF_INET;
	inet_pton( AF_INET, IP, &address.sin_addr);
	address.sin_port = htons(PORT);

	pid_t pid = getpid();
	unsigned cc = 0;
	cpu_set_t mask;
	CPU_ZERO(&mask);
	CPU_SET(i, &mask);

	printf("pid=%d %d\n", pid, i);
	if (sched_getaffinity(pid, sizeof(mask), &mask) < 0) {
		printf("sched_getaffinity err\n");
	}

	int listenfd = socket(PF_INET, SOCK_STREAM, 0);
	assert(listenfd >= 0);

	int val =1;
	/*set SO_REUSEPORT*/
	if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEPORT, &val, sizeof(val)) < 0) {
		perror("setsockopt()");
	}

	val = 1000 + i;
	if (setsockopt(listenfd, SOL_TCP, TCP_MAXSEG, &val, sizeof(val))<0) {
		perror("setsockopt()");
	}

	int ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
	assert(ret != -1);

	ret = listen(listenfd, 5);
	assert(ret != -1);
	while (1) {
		cc ++;
		if (cc % 100 == 0)
			printf("thread=%d cc=%d\n", i, cc);
//        printf("I am worker %d, begin to accept connection.\n", i);
		struct sockaddr_in client_addr;
		socklen_t client_addrlen = sizeof( client_addr );
		int connfd = accept(listenfd, (struct sockaddr*)&client_addr, &client_addrlen);
		if (connfd != -1) {
//            printf("worker %d accept a connection success. ip:%s, prot:%d\n", i, inet_ntoa(client_addr.sin_addr), client_addr.sin_port);
		} else {
//            printf("worker %d accept a connection failed,error:%s", i, strerror(errno));
		}
		char buffer[MAXLINE];
//        int nbytes = read(connfd, buffer, MAXLINE);
//        printf("read from client is:%s\n", buffer);
//        write(connfd, buffer, nbytes);
		close(connfd);
	}
	return 0;
}

int main()
{
	int i = 0;
	for (i = 0; i < WORKER; i++) {
		printf("Create worker %d\n", i);
		pid_t pid = fork();
		/*child  process */
		if (pid == 0) {
			worker(i);
		}
		if (pid < 0) {
			printf("fork error");
		}
	}
	/*wait child process*/
	while (wait(NULL) != 0)
		;
	if (errno == ECHILD) {
		fprintf(stderr, "wait error:%s\n", strerror(errno));
	}
	return 0;
}

veth虚拟网络设备的qdisc

http://hustcat.github.io/veth/

http://hustcat.github.io/vlan-performance-problem/

veth设备qdisc队列，而环回设备/桥接设备是没qdisc队列的，参考br_dev_setup函数。

内核实现

在注册（创建）设备时，qdisc设置为noop_qdisc， register_netdevice -> dev_init_scheduler

1
2
3
4
5
6
7
8

void dev_init_scheduler(struct net_device *dev)
{
	dev->qdisc = &noop_qdisc;
	netdev_for_each_tx_queue(dev, dev_init_scheduler_queue, &noop_qdisc);
	dev_init_scheduler_queue(dev, &dev->rx_queue, &noop_qdisc);

	setup_timer(&dev->watchdog_timer, dev_watchdog, (unsigned long)dev);
}

打开设备时，如果没有配置qdisc时，就指定为默认的pfifo_fast队列： dev_open -> dev_activate，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

void dev_activate(struct net_device *dev)
{
	int need_watchdog;

	/* No queueing discipline is attached to device;
	   create default one i.e. pfifo_fast for devices,
	   which need queueing and noqueue_qdisc for
	   virtual interfaces
	 */

	if (dev->qdisc == &noop_qdisc)
		attach_default_qdiscs(dev);
...
}

static void attach_default_qdiscs(struct net_device *dev)
{
	struct netdev_queue *txq;
	struct Qdisc *qdisc;

	txq = netdev_get_tx_queue(dev, 0);

	if (!netif_is_multiqueue(dev) || dev->tx_queue_len == 0) {
		netdev_for_each_tx_queue(dev, attach_one_default_qdisc, NULL);
		dev->qdisc = txq->qdisc_sleeping;
		atomic_inc(&dev->qdisc->refcnt);
	} else {///multi queue
		qdisc = qdisc_create_dflt(dev, txq, &mq_qdisc_ops, TC_H_ROOT);
		if (qdisc) {
			qdisc->ops->attach(qdisc);
			dev->qdisc = qdisc;
		}
	}
}

static void attach_one_default_qdisc(struct net_device *dev,
				     struct netdev_queue *dev_queue,
				     void *_unused)
{
	struct Qdisc *qdisc;

	if (dev->tx_queue_len) {
		qdisc = qdisc_create_dflt(dev, dev_queue,
					  &pfifo_fast_ops, TC_H_ROOT);
		if (!qdisc) {
			printk(KERN_INFO "%s: activation failed\n", dev->name);
			return;
		}

		/* Can by-pass the queue discipline for default qdisc */
		qdisc->flags |= TCQ_F_CAN_BYPASS;
	} else {
		qdisc =  &noqueue_qdisc;
	}
	dev_queue->qdisc_sleeping = qdisc;
}

创建noqueue

开始尝试直接删除设备默认的pfifo_fast队列，发现会出错：

1
2
3
4
5
6

# tc qdisc del dev vethd4ea root
RTNETLINK answers: No such file or directory
# tc  -s qdisc ls dev vethd4ea
qdisc pfifo_fast 0: root refcnt 2 bands 3 priomap  1 2 2 2 1 2 0 0 1 1 1 1 1 1 1 1
 Sent 29705382 bytes 441562 pkt (dropped 0, overlimits 0 requeues 0) 
 backlog 0b 0p requeues 0

后来看到Jesper Brouer给出一个替换默认队列的方式，尝试了一下，成功完成。

替换默认的qdisc队列

1
2
3
4
5
6
7
8

# tc qdisc replace dev vethd4ea root pfifo limit 100
# tc  -s qdisc ls dev vethd4ea                      
qdisc pfifo 8001: root refcnt 2 limit 100p
 Sent 264 bytes 4 pkt (dropped 0, overlimits 0 requeues 0) 
 backlog 0b 0p requeues 0 
# ip link show vethd4ea
9: vethd4ea: <BROADCAST,UP,LOWER_UP> mtu 1500 qdisc pfifo master docker0 state UP mode DEFAULT qlen 1000
link/ether 3a:15:3b:e1:d7:6d brd ff:ff:ff:ff:ff:ff

修改队列长度

1

# ifconfig vethd4ea txqueuelen 0

删除qdisc

1
2
3
4

# tc qdisc del dev vethd4ea root                    
# ip link show vethd4ea                
9: vethd4ea: <BROADCAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP mode DEFAULT 
link/ether 3a:15:3b:e1:d7:6d brd ff:ff:ff:ff:ff:ff

可以看到，UP的veth设备成功修改成noqueue。

qdisc 的创建过程

http://blog.chinaunix.net/uid-26902809-id-4106161.html

register_netdevice会初始化netdev的Tx调度discipline, 缺省使用noop_qdisc

1
2
3
4
5
6
7
8
9
10
11
12
13

register_netdevice
--->dev_init_scheduler


void dev_init_scheduler(struct net_device *dev)
{
	dev->qdisc = &noop_qdisc; //缺省为设备配置noop_qdisc
	netdev_for_each_tx_queue(dev, dev_init_scheduler_queue, &noop_qdisc); //缺省为每个队列配置noop_qdisc
	if (dev_ingress_queue(dev))
		dev_init_scheduler_queue(dev, dev_ingress_queue(dev), &noop_qdisc);

	setup_timer(&dev->watchdog_timer, dev_watchdog, (unsigned long)dev);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

dev_open
--->__dev_open
---->dev_activate
---->attach_default_qdiscs
---->attach_one_default_qdisc
为单队列的设备创建pfifo_fast的qdisc

static void attach_one_default_qdisc(struct net_device *dev,
				struct netdev_queue *dev_queue,
				void *_unused)
{
	struct Qdisc *qdisc = &noqueue_qdisc;

	if (dev->tx_queue_len) {
		qdisc = qdisc_create_dflt(dev_queue,
				&pfifo_fast_ops, TC_H_ROOT);
		if (!qdisc) {
			netdev_info(dev, "activation failed\n");
			return;
		}
	}
	dev_queue->qdisc_sleeping = qdisc;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

dev_open
--->__dev_open
---->dev_activate
---->attach_default_qdiscs
---->qdisc_create_dflt
为多队列的设备创建mq_qdisc, 创建完mq_qdisc， 接着调用mq_qdisc_ops->mq_init函数为每个队列创建pfifo_fast_ops的qdisc

struct Qdisc *qdisc_create_dflt(struct netdev_queue *dev_queue,
			struct Qdisc_ops *ops, unsigned int parentid)
{
	struct Qdisc *sch;

	sch = qdisc_alloc(dev_queue, ops);
	if (IS_ERR(sch))
		goto errout;
	sch->parent = parentid;

	if (!ops->init || ops->init(sch, NULL) == 0)
		return sch;

	qdisc_destroy(sch);
errout:
	return NULL;
}
EXPORT_SYMBOL(qdisc_create_dflt);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

dev_open
--->__dev_open
---->dev_activate
---->attach_default_qdiscs
static void attach_default_qdiscs(struct net_device *dev)
{
	struct netdev_queue *txq;
	struct Qdisc *qdisc;

	txq = netdev_get_tx_queue(dev, 0);

	if (!netif_is_multiqueue(dev) || dev->tx_queue_len == 0) {
		netdev_for_each_tx_queue(dev, attach_one_default_qdisc, NULL);
		dev->qdisc = txq->qdisc_sleeping;
		atomic_inc(&dev->qdisc->refcnt);
	} else {
		qdisc = qdisc_create_dflt(txq, &mq_qdisc_ops, TC_H_ROOT);
		if (qdisc) {
			qdisc->ops->attach(qdisc);
			dev->qdisc = qdisc;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

dev_open函数会调用dev_activate：
a. 为单队列的设备创建pfifo_fast的qdisc
b. 为多队列的设备创建mq_qdisc, 创建完mq_qdisc， 接着调用mq_qdisc_ops->mq_init函数为每个队列创建pfifo_fast_ops的qdisc
dev_open
--->__dev_open
---->dev_activate

void dev_activate(struct net_device *dev)
{
	int need_watchdog;

	/* No queueing discipline is attached to device;
	   create default one i.e. pfifo_fast for devices,
	   which need queueing and noqueue_qdisc for
	   virtual interfaces
	*/

	if (dev->qdisc == &noop_qdisc)
		attach_default_qdiscs(dev);

	if (!netif_carrier_ok(dev))
	/* Delay activation until next carrier-on event */
		return;

	need_watchdog = 0;
	netdev_for_each_tx_queue(dev, transition_one_qdisc, &need_watchdog);
	if (dev_ingress_queue(dev))
		transition_one_qdisc(dev, dev_ingress_queue(dev), NULL);

	if (need_watchdog) {
		dev->trans_start = jiffies;
		dev_watchdog_up(dev);
	}
}