linux tun/tap设备的实现（kennel 3.10）

——lvyilong316

什么是tun/tap？

     TUN/TAP虚拟网络设备为用户空间程序提供了网络数据包的发送和接收能力。他既可以当做点对点设备（TUN），也可以当做以太网设备（TAP）。实际上，不仅Linux支持TUN/TAP虚拟网络设备，其他UNIX也是支持的，他们之间只有少许差别。

     TUN/TAP虚拟网络设备的原理比较简单，他在Linux内核中添加了一个TUN/TAP虚拟网络设备的驱动程序和一个与之相关连的字符设备/dev/net/tun，字符设备tun作为用户空间和内核空间交换数据的接口。当内核将数据包发送到虚拟网络设备时，数据包被保存在设备相关的一个队列中，直到用户空间程序通过打开的字符设备tun的描述符读取时，它才会被拷贝到用户空间的缓冲区中，其效果就相当于，数据包直接发送到了用户空间。通过系统调用write发送数据包时其原理与此类似。

     值得注意的是：一次read系统调用，有且只有一个数据包被传送到用户空间，并且当用户空间的缓冲区比较小时，数据包将被截断，剩余部分将永久地消失，write系统调用与read类似，每次只发送一个数据包。所以在编写此类程序的时候，请用足够大的缓冲区，直接调用系统调用read/write，避免采用C语言的带缓存的IO函数。

      TUN/TAP是一类虚拟网卡的驱动。网卡驱动很好理解，就是netdev+driver，最后将数据包通过这些驱动发送出去，netdev可以参考内核或者OVS代码，基本使用的就是几个钩子函数。

     虚拟网卡就是没有物理设备的网卡，那么他的驱动就是需要开发人员自己编写。一般虚拟网卡用于实现物理网卡不愿意做的事情，例如tunnel封装（用于vpn，openvpn（ ）和Vtun( )），多个物理网卡的聚合等。一般使用虚拟网卡的方式与使用物理网卡一样，在协议栈中通过回调函数call到虚拟网卡的API，经过虚拟网卡处理之后的数据包再由协议栈发送出去。

tun/tap的使用

     linux2.4内核之后代码默认编译tun、tap驱动，使用的时候只需要将模块加载即可（modprobe tun，mknod /dev/net/tun c 10 200）。运行tun、tap设备之后，会在内核空间添加一个杂项设备（miscdevice，类比字符设备、块设备等）/dev/net/tun，实质上是主设备号10的字符设备。从功能上看，tun设备驱动主要应该包括两个部分，一是虚拟网卡驱动，其实就是虚拟网卡中对skb进行封装解封装等操作；二是字符设备驱动，用于内核空间与用户空间的交互。

     源代码在/drivers/net/tun.c中，与其他netdev类似，tun这个netdev也提供open、close、read、write等API。在分析 TUN/TAP驱动实现前，我们先看下如何使用。使用tun/tap设备的示例程序(摘自openvpn开源项目 ，tun.c文件)

int open_tun (const char *dev, char *actual, int size)
{
  struct ifreq ifr;
  int fd;
  char *device = "/dev/net/tun";
  if ((fd = open (device, O_RDWR)) < 0) //创建描述符
    msg (M_ERR, "Cannot open TUN/TAP dev %s", device);
  memset (&ifr, 0, sizeof (ifr));
  ifr.ifr_flags = IFF_NO_PI;
  if (!strncmp (dev, "tun", 3)) {
      ifr.ifr_flags |= IFF_TUN;
   }
  else if (!strncmp (dev, "tap", 3)) {
      ifr.ifr_flags |= IFF_TAP;
    }
  else {
    msg (M_FATAL, "I don't recognize device %s as a TUN or TAP device",dev);
    }
  if (strlen (dev) > 3)      /* unit number specified? */
    strncpy (ifr.ifr_name, dev, IFNAMSIZ);
  if (ioctl (fd, TUNSETIFF, (void *) &ifr) < 0) //打开虚拟网卡
    msg (M_ERR, "Cannot ioctl TUNSETIFF %s", dev);
  set_nonblock (fd);
  msg (M_INFO, "TUN/TAP device %s opened", ifr.ifr_name);
  strncpynt (actual, ifr.ifr_name, size);
  return fd;
}

      调用上述函数后，就可以在shell命令行下使用ifconfig 命令配置虚拟网卡了：

ifconfig devname 10.0.0.1 up

route add -net 10.0.0.2 netmask 255.255.255.255 dev devname

配置好虚拟网卡地址后，就可以通过生成的字符设备描述符，在程序中使用read和write函数就可以读取或者发送给虚拟的网卡数据了。

tun/tap的实现

    tun/tap设备驱动的开始也是init函数，其中主要调用了misc_register注册了一个miscdev设备。

static int __init tun_init(void)
{
/*……*/
    ret = misc_register(&tun_miscdev);
    /*……*/
}

而tun_miscdev得定义如下：

static struct miscdevice tun_miscdev = {
    .minor = TUN_MINOR,
    .name = "tun",
    .nodename = "net/tun",
    .fops = &tun_fops,
}

    注册完这个设备之后将在系统中生成一个“/dev/net/tun”文件，同字符设备类似，当应用程序使用open系统调用打开这个文件时，将生成file文件对象，而其file_operations将指向tun_fops。

static const struct file_operations tun_fops = {
    .owner    = THIS_MODULE,
    .llseek = no_llseek,
    .read = do_sync_read,
    .aio_read = tun_chr_aio_read,
    .write = do_sync_write,
    .aio_write = tun_chr_aio_write,
    .poll    = tun_chr_poll,
    .unlocked_ioctl    = tun_chr_ioctl,
#ifdef CONFIG_COMPAT
    .compat_ioctl = tun_chr_compat_ioctl,
#endif
    .open    = tun_chr_open,
    .release = tun_chr_close,
    .fasync = tun_chr_fasync
};

下面我们以应用层使用的步骤来分析内核的对应实现。应用层首先调用open打开“/dev/net/tun”，这将最终调用tun_fops的open函数，即tun_chr_open。

static int tun_chr_open(struct inode *inode, struct file * file)
{
    struct tun_file *tfile;

    DBG1(KERN_INFO, "tunX: tun_chr_open\n");

    /*分配并初始化struct tun_file结构*/
    tfile = (struct tun_file *)sk_alloc(&init_net, AF_UNSPEC, GFP_KERNEL,
                    &tun_proto);
    if (!tfile)
        return -ENOMEM;
    rcu_assign_pointer(tfile->tun, NULL);
    tfile->net = get_net(current->nsproxy->net_ns);
    tfile->flags = 0;

    rcu_assign_pointer(tfile->socket.wq, &tfile->wq);
    init_waitqueue_head(&tfile->wq.wait);

    tfile->socket.file = file;
    /*设置struct tun_file的socket成员ops*/
    tfile->socket.ops = &tun_socket_ops;

    sock_init_data(&tfile->socket, &tfile->sk);
    sk_change_net(&tfile->sk, tfile->net);

    tfile->sk.sk_write_space = tun_sock_write_space;
    tfile->sk.sk_sndbuf = INT_MAX;
    /*将struct tun_file作为file的私有字段，而file就是每次应用调用open打开/dev/net/tun生成的*/
    file->private_data = tfile;
    set_bit(SOCK_EXTERNALLY_ALLOCATED, &tfile->socket.flags);
    INIT_LIST_HEAD(&tfile->next);

    sock_set_flag(&tfile->sk, SOCK_ZEROCOPY);

    return 0;
}

经过这个函数后，整个数据结构的关系就如下图所示。注意这里的struct file结构就是每次应用调用open打开/dev/net/tun生成的。

    应用程序执行完open操作后，一般会执行ioctl (fd, TUNSETIFF, (void *) &ifr) 来真正创建tap/tun设备。这将最终调用tun_ops中的tun_chr_ioctl函数。tun_chr_ioctl中会调用__tun_chr_ioctl。

static long __tun_chr_ioctl(struct file *file, unsigned int cmd,
                unsigned long arg, int ifreq_len)
{
    struct tun_file *tfile = file->private_data;
    struct tun_struct *tun;
    void __user* argp = (void __user*)arg;
    struct ifreq ifr;
    kuid_t owner;
    kgid_t group;
    int sndbuf;
    int vnet_hdr_sz;
    int ret;

    if (cmd == TUNSETIFF || cmd == TUNSETQUEUE || _IOC_TYPE(cmd) == 0x89) {
        if (copy_from_user(&ifr, argp, ifreq_len))
            return -EFAULT;
    } else {
        memset(&ifr, 0, sizeof(ifr));
    }
    if (cmd == TUNGETFEATURES) {
        /* Currently this just means: "what IFF flags are valid?".
         * This is needed because we never checked for invalid flags on
         * TUNSETIFF. */
        return put_user(IFF_TUN | IFF_TAP | IFF_NO_PI | IFF_ONE_QUEUE |
                IFF_VNET_HDR | IFF_MULTI_QUEUE,
                (unsigned int __user*)argp);
    } else if (cmd == TUNSETQUEUE)
        return tun_set_queue(file, &ifr);

    ret = 0;
    rtnl_lock();
/*获取tun_struct结构，首次调用TUNSETIFF时为NULL*/
    tun = __tun_get(tfile);
    if (cmd == TUNSETIFF && !tun) {
        ifr.ifr_name[IFNAMSIZ-1] = '\0';

        ret = tun_set_iff(tfile->net, file, &ifr);

        if (ret)
            goto unlock;

        if (copy_to_user(argp, &ifr, ifreq_len))
            ret = -EFAULT;
        goto unlock;
    }

    ret = -EBADFD;
    if (!tun)
        goto unlock;

    ret = 0;
    switch (cmd) {
    case TUNGETIFF:
/*……*/
}
unlock:
rtnl_unlock();
if (tun)
    tun_put(tun);
return ret;
}

可以看出如果cmd是TUNSETIFF，则会调用tun_set_iff函数。

static int tun_set_iff(struct net *net, struct file *file, struct ifreq *ifr)
{
    struct tun_struct *tun;
    struct tun_file *tfile = file->private_data;
    struct net_device *dev;
    int err;

    if (tfile->detached)
        return -EINVAL;

    dev = __dev_get_by_name(net, ifr->ifr_name);
    if (dev) { /*首次调用dev为NULL*/
         /*略*/
    }
    else {
        char *name;
        unsigned long flags = 0;
        int queues = ifr->ifr_flags & IFF_MULTI_QUEUE ?
                 MAX_TAP_QUEUES : 1;

        if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
            return -EPERM;

        /* Set dev type */
        if (ifr->ifr_flags & IFF_TUN) { /*tun设备*/
            /* TUN device */
            flags |= TUN_TUN_DEV;
            name = "tun%d";
        } else if (ifr->ifr_flags & IFF_TAP) { /*tap设备*/
            /* TAP device */
            flags |= TUN_TAP_DEV;
            name = "tap%d";
        } else
            return -EINVAL;

        if (*ifr->ifr_name)
            name = ifr->ifr_name;
        /*分配net_device结构，并将struct tun_struct作为其private结构*/
        dev = alloc_netdev_mqs(sizeof(struct tun_struct), name,
                       tun_setup, queues, queues);

        if (!dev)
            return -ENOMEM;

        dev_net_set(dev, net);
        dev->rtnl_link_ops = &tun_link_ops;

        tun = netdev_priv(dev);
        tun->dev = dev;
        tun->flags = flags; /*标识设备的类型，tun或tap*/
        tun->txflt.count = 0;
        tun->vnet_hdr_sz = sizeof(struct virtio_net_hdr);

        tun->filter_attached = false;
        tun->sndbuf = tfile->socket.sk->sk_sndbuf;

        spin_lock_init(&tun->lock);
        /*根据设备类型是tap或tun初始化net_device结构，关键是其dev->netdev_ops 成员*/
        tun_net_init(dev);

        err = tun_flow_init(tun);
        if (err < 0)
            goto err_free_dev;

        dev->hw_features = NETIF_F_SG | NETIF_F_FRAGLIST |
            TUN_USER_FEATURES;
        dev->features = dev->hw_features;
        dev->vlan_features = dev->features;

        INIT_LIST_HEAD(&tun->disabled);
        /*将tun（tun_struct）和file的private，即tun_file关联*/
        err = tun_attach(tun, file);
        if (err < 0)
            goto err_free_flow;
        /*注册net_device，完成网络设备驱动程序的注册*/
        err = register_netdevice(tun->dev);
        if (err < 0)
            goto err_detach;

        if (device_create_file(&tun->dev->dev, &dev_attr_tun_flags) ||
            device_create_file(&tun->dev->dev, &dev_attr_owner) ||
            device_create_file(&tun->dev->dev, &dev_attr_group))
            pr_err("Failed to create tun sysfs files\n");
    }
    /*……*/
    if (netif_running(tun->dev)) /*运行网卡qdisc 队列*/
        netif_tx_wake_all_queues(tun->dev);

    strcpy(ifr->ifr_name, tun->dev->name);
    return 0;

err_detach:
    tun_detach_all(dev);
err_free_flow:
    tun_flow_uninit(tun);
    security_tun_dev_free_security(tun->security);
err_free_dev:
    free_netdev(dev);
    return err;
}

经过这个函数之后tun/tap的相关数据结构组织就如下图所示了。

数据通道实现

下面我们看tun/tap设备是如何进行数据转发的，我们从两个方向分析，首先是用户态到内核态，然后是内核态到用户态。整个过程如下图所示。

用户态到内核态

用户态调用write向tun/tap设备中写入数据，最终调用kernel中对应file结构中的tun_fops的write函数。整个调用路径如下。

    

注意tun/tap设备的net_device并没有向bridge那样注册rx_handle接受函数，所以经过netif_receive_skb后就进入了上层协议栈，对于系统来说就像从物理网卡eth0接受上来的包一样。如果用户态想在接受，就要创建socket了。

内核态到用户态

     从tun/tap设备发出的数据包（这里的发出是指例如将tap设备加入独立的容器或namespace中后通过容器网卡发出，用户态的write是不会导致数据包从tap设备发出，而是送给协议栈），就需要调用net_device的ndo_start_xmit函数了。整个流程如下图（橙色的线）。这里要说明一点，有人可能会疑惑如果所有进程都打开”/dev/net/tun”读取数据不会混淆吗？答案是不会的，因为每个进程open后内核都有自己的file文件对象，同时TUNSETIFF后也会有不同的net_device设备对象。

说明，要区分把tap设备直通给容器/namespace和把veth pair的一端通给容器/namespace区分开，tap设备通给容器/namespace，则容器内的数据发送会走上述“内核到用户态”的逻辑，用户态需要有进程以读文件形象等待tap数据的接收；veth pair中的一端时其ndo_start_xmit函数和tap设备不同时直接发送另一端veth pair的。