ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 系统相关> 文章详细

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

2020-12-01 13:57:38  阅读：320  来源： 互联网

标签：tap file ifr 3.10 dev tun net struct


什么是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（ http://openvpn.sourceforge.net）和Vtun( http://vtun.sourceforge.net)），多个物理网卡的聚合等。一般使用虚拟网卡的方式与使用物理网卡一样，在协议栈中通过回调函数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开源项目 http://openvpn.sourceforge.net，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。

  • 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中会调用__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函数。

  • 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设备发出的数据包，就需要调用net_device的ndo_start_xmit函数了。整个流程如下图（橙色的线）。这里要说明一点，有人可能会疑惑如果所有进程都打开”/dev/net/tun”读取数据不会混淆吗？答案是不会的，因为每个进程open后内核都有自己的file文件对象，同时TUNSETIFF后也会有不同的net_device设备对象。

 

 

 

 

 

 

 

 

 

 

 

 

 

标签：tap,file,ifr,3.10,dev,tun,net,struct
来源： https://blog.csdn.net/weixin_39094034/article/details/110429862

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有