系统相关
首页 > 系统相关> > linux tun/tap设备的实现(kennel 3.10)

linux tun/tap设备的实现(kennel 3.10)

作者:互联网

什么是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。

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设备发出的数据包,就需要调用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