***-server 虚拟工作模式tun 和tap的区别

女爷i 2022-01-10 10:41 1260阅读 0赞

长期以来对tun和tap这对兄弟分不太清，今天下定决心研究了一下代码，总算是搞明白了。

首先它们都是从/dev/net/tun里ioctl出来的虚拟设备，一个是通过IFF\_TUN，另一个是 IFF\_TAP。最好的例子莫过于\*\*\*c里面的代码了。

PLAIN TEXTC:   
1.int tun\_open(char \*dev, enum if\_mode\_enum mode)  
2.\{  
3.        struct ifreq ifr;  
4.        int fd, err;  
5.   
6.        if ((fd = open("/dev/net/tun", O\_RDWR)) <0) \{  
7.                error(0, errno,  
8.                        "can't open /dev/net/tun, check that it is either device char 10 200 or (with DevFS) a symlink to ../misc/net/tun (not misc/net/tun)");  
9.                return -1;  
10.        \}  
11.   
12.        memset(&ifr, 0, sizeof(ifr));  
13.        ifr.ifr\_flags = ((mode == IF\_MODE\_TUN) ? IFF\_TUN : IFF\_TAP) | IFF\_NO\_PI;  
14.        if (\*dev)  
15.                strncpy(ifr.ifr\_name, dev, IFNAMSIZ);  
16.   
17.        if ((err = ioctl(fd, TUNSETIFF, (void \*)&ifr)) <0) \{  
18.                close(fd);  
19.                return err;  
20.        \}  
21.        strcpy(dev, ifr.ifr\_name);  
22.        return fd;  
23.\}  
用的ioctl的命令都是同一个TUNSETIFF。

虽然是出自一个娘，但它们仍然有大的不同。tun是点对点的设备，而tap是一个普通的以太网卡设备。也就是说，tun设备其实完全不需要有物理地址的！它收到和发出的包不需要arp，也不需要有数据链路层的头！  
而tap设备则是有完整的物理地址和完整的以太网帧。

用一个实际的例子来验证一下：

tap0      Link encap:Ethernet  HWaddr 0E:78:39:78:E7:A7  
          inet addr:192.168.1.109  Bcast:192.168.1.255  Mask:255.255.255.0  
          inet6 addr: fe80::c78:39ff:fe78:e7a7/64 Scope:Link  
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1  
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0  
          TX packets:0 errors:0 dropped:21 overruns:0 carrier:0  
          collisions:0 txqueuelen:500  
          RX bytes:0 (0.0 b)  TX bytes:0 (0.0 b)

tun0      Link encap:UNSPEC  HWaddr 00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00  
          inet addr:X.X.X.X  P-t-P:X.X.X.X  Mask:255.255.255.255  
          UP POINTOPOINT RUNNING NOARP MULTICAST  MTU:1412  Metric:1  
          RX packets:6 errors:0 dropped:0 overruns:0 frame:0  
          TX packets:6 errors:0 dropped:0 overruns:0 carrier:0  
          collisions:0 txqueuelen:500  
          RX bytes:690 (690.0 b)  TX bytes:402 (402.0 b)

% ethtool -i tun0  
driver: tun  
version: 1.6  
firmware-version: N/A  
bus-info: tun  
% ethtool -i tap0  
driver: tun  
version: 1.6  
firmware-version: N/A  
bus-info: tap  
继续回来看代码。还是\*\*\*c的代码 tunip.c，看它发送的时候做了什么处理：

PLAIN TEXTC:   
1.static int tun\_send\_ip(struct sa\_block \*s)  
2.\{  
3.        int sent, len;  
4.        uint8\_t \*start;  
5.   
6.        start = s->ipsec.rx.buf;  
7.        len   = s->ipsec.rx.buflen;  
8.   
9.        if (opt\_if\_mode == IF\_MODE\_TAP) \{  
10.\#ifndef \_\_sun\_\_  
11.                /\*  
12.                 \* Add ethernet header before s->ipsec.rx.buf where  
13.                 \* at least ETH\_HLEN bytes should be available.  
14.                 \*/  
15.                struct ether\_header \*eth\_hdr = (struct ether\_header \*) (s->ipsec.rx.buf - ETH\_HLEN);  
16.   
17.                memcpy(eth\_hdr->ether\_dhost, s->tun\_hwaddr, ETH\_ALEN);  
18.                memcpy(eth\_hdr->ether\_shost, s->tun\_hwaddr, ETH\_ALEN);  
19.   
20.                /\* Use a different MAC as source \*/  
21.                eth\_hdr->ether\_shost\[0\] ^= 0x80; /\* toggle some visible bit \*/  
22.                eth\_hdr->ether\_type = htons(ETHERTYPE\_IP);  
23.   
24.                start = (uint8\_t \*) eth\_hdr;  
25.                len += ETH\_HLEN;  
26.\#endif  
27.        \}  
28.   
29.        sent = tun\_write(s->tun\_fd, start, len);  
30.        if (sent != len)  
31.                syslog(LOG\_ERR, "truncated in: %d -> %d\\n", len, sent);  
32.        hex\_dump("Tx pkt", start, len, NULL);  
33.        return 1;  
34.\}  
从上面的代码我们很容易看出：

1. 所谓发送就是对/dev/net/tun进行写操作。对称的，所谓接收就是读操作。  
2. 如果是tap设备，发送时还要多加一个以太网的头。

我们再看内核中对应的代码是怎么处理的，在drivers/net/tun.c 中的 tun\_get\_user()：

PLAIN TEXTC:   
1.switch (tun->flags & TUN\_TYPE\_MASK) \{  
2.        case TUN\_TUN\_DEV:  
3.                if (tun->flags & TUN\_NO\_PI) \{  
4.                //...  
5.                \}  
6.   
7.                skb\_reset\_mac\_header(skb);  
8.                skb->protocol = pi.proto;  
9.                skb->dev = tun->dev;  
10.                break;  
11.        case TUN\_TAP\_DEV:  
12.                skb->protocol = eth\_type\_trans(skb, tun->dev);  
13.                break;  
内核直接忽略了 tun 设备的以太网帧。现在，整个流程我们就已经很清楚了。

可是，上面只是用\*\*\*c的例子。我们知道，实际中像kvm虚拟机才是tap的使用大户，我们很有必要看一下kvm是怎么使用tap设备的。为了方便起见，我们不看 qemu-kvm，因为它的代码过于复杂，我们看一个简单的kvm   
tools的实现。  
这部分的主要代码在 virtio/net.c里面，virtio\_net\_\_tap\_init()是在启动虚拟机时初始化tap设备的，然后启动两个线程分别监控tap设备的收发，代码是virtio\_net\_rx\_thread()和virtio\_net\_tx\_thread()，  
它们负责把进来的IO操作转换成对/dev/net/tun的读写。可是，IO操作是怎么进来的呢？这是关键。  
顺着代码里的“针”一个个找下去，我们不难发现，IO操作是由kvm模拟出来的。首先它会把CPU指令中对应的IO操作进行转化，这部分在内核中，arch/x86/kvm/emulate.c::x86\_emulate\_insn()：

PLAIN TEXTC:   
1.do\_io\_in:  
2.                c->dst.bytes = min(c->dst.bytes, 4u);  
3.                if (!emulator\_io\_permited(ctxt, ops, c->src.val, c->dst.bytes)) \{  
4.                        emulate\_gp(ctxt, 0);  
5.                        goto done;  
6.                \}  
7.                if (!pio\_in\_emulated(ctxt, ops, c->dst.bytes, c->src.val,  
8.                                     &c->dst.val))  
9.                        goto done; /\* IO is needed \*/  
10.                break;pio\_in\_emulated() 调用的 emulator\_pio\_in\_emulated() 会进一步触发KVM\_EXIT\_IO：

PLAIN TEXTC:   
1.static int emulator\_pio\_in\_emulated(int size, unsigned short port, void \*val,  
2.                             unsigned int count, struct kvm\_vcpu \*vcpu)  
3.\{  
4.        if (vcpu->arch.pio.count)  
5.                goto data\_avail;  
6.   
7.        trace\_kvm\_pio(0, port, size, 1);  
8.   
9.        vcpu->arch.pio.port = port;  
10.        vcpu->arch.pio.in = 1;  
11.        vcpu->arch.pio.count  = count;  
12.        vcpu->arch.pio.size = size;  
13.   
14.        if (!kernel\_pio(vcpu, vcpu->arch.pio\_data)) \{  
15.        data\_avail:  
16.                memcpy(val, vcpu->arch.pio\_data, size \* count);  
17.                vcpu->arch.pio.count = 0;  
18.                return 1;  
19.        \}  
20.   
21.        vcpu->run->exit\_reason = KVM\_EXIT\_IO;  
22.        vcpu->run->io.direction = KVM\_EXIT\_IO\_IN;  
23.        vcpu->run->io.size = size;  
24.        vcpu->run->io.data\_offset = KVM\_PIO\_PAGE\_OFFSET \* PAGE\_SIZE;  
25.        vcpu->run->io.count = count;  
26.        vcpu->run->io.port = port;  
27.   
28.        return 0;  
29.\}  
内核部分结束，转到用户空间，用户空间的 vcpu 会捕捉到这个事件，在 kvm-cpu.c::kvm\_cpu\_\_start() 中：

PLAIN TEXTC:   
1.case KVM\_EXIT\_IO: \{  
2.                        bool ret;  
3.   
4.                        ret = kvm\_\_emulate\_io(cpu->kvm,  
5.                                        cpu->kvm\_run->io.port,  
6.                                        (u8 \*)cpu->kvm\_run +  
7.                                        cpu->kvm\_run->io.data\_offset,  
8.                                        cpu->kvm\_run->io.direction,  
9.                                        cpu->kvm\_run->io.size,  
10.                                        cpu->kvm\_run->io.count);  
11.   
12.                        if (!ret)  
13.                                goto panic\_kvm;  
14.                        break;  
15.                \}kvm\_\_emulate\_io() 就会调用在 virtio/net.c 注册的 virtio\_net\_pci\_io\_in()，数据就这样流向了 tap 网卡了。

转载于:https://blog.51cto.com/2364821/1261010