tun/tap虚拟网卡设备
物理网卡设备在发送数据包时，将由线缆将数据包发送到对端设备上。
VETH网卡设备，在发送数据包时，将数据包直接交由配对的网卡收包并上送协议栈。
tun/tap虚拟网卡设备在网卡发包时，将数据包存放在一个缓冲区，当进程读取特定字符设备时，将缓冲区的数据包上送给进程。当进程写特定字符设备时，将数据包发送给网卡收包并上送协议栈。
个人觉得 这种特性就是讲raw socket 和 VETH网卡设备结合起来。当前使用这种网卡设备较多的场景有两个，VPN设备，通过协议栈将隧道数据上送到用户态进程，对隧道中的数据进行解密，然后将数据通过写入字符设备，再次通过协议栈对解密后的数据进行路由或者上送到其他进程处理。第二个比较常用的场景是在虚拟化中。tun/tap设备加入网桥中，客户机发包时通过字符设备将数据包下发到桥中，客户机收包时，在缓冲区收取桥送过来的数据。

由于这个网卡涉及到字符设备和网卡设备，因此有两个关键的私有数据结构
字符设备私有数据结构

struct tun_file {
        struct sock sk;                         //用来唤醒阻塞的用户态读取进程
        struct socket socket;                   //在vhost_net中用来在内核直接读取和写入数据
        struct socket_wq wq;                    //读取进程阻塞等待变量
        struct tun_struct __rcu *tun;           //字符设备对应的网卡设备的私有数据结构
        struct fasync_struct *fasync;
        /* only used for fasnyc */
        unsigned int flags;
        union {
                u16 queue_index;
                unsigned int ifindex;
        };
        struct list_head next;
        struct tun_struct *detached;
        struct skb_array tx_array;               //该字符设备的缓冲区，网卡发送数据时直接将数据填入该缓冲区
};

网卡设备私有数据结构

struct tun_struct {
        struct tun_file __rcu   *tfiles[MAX_TAP_QUEUES]; //网卡设备对应的字符设备。一个网卡设备可以对应多个字符设备的打开实例，多队列
        unsigned int            numqueues;               //总共的队列数量
        unsigned int            flags;                  //tun/tap设备特性描述
        kuid_t                  owner;
        kgid_t                  group;

        struct net_device       *dev;                   //对应的网卡设备
        netdev_features_t       set_features;
#define TUN_USER_FEATURES (NETIF_F_HW_CSUM|NETIF_F_TSO_ECN|NETIF_F_TSO| \
                          NETIF_F_TSO6|NETIF_F_UFO)

        int                     align;
        int                     vnet_hdr_sz;
        int                     sndbuf;
        struct tap_filter       txflt;
        struct sock_fprog       fprog;
        /* protected by rtnl lock */
        bool                    filter_attached;
#ifdef TUN_DEBUG
        int debug;
#endif
        spinlock_t lock;
        struct hlist_head flows[TUN_NUM_FLOW_ENTRIES];
        struct timer_list flow_gc_timer;
        unsigned long ageing_time;
        unsigned int numdisabled;
        struct list_head disabled;
        void *security;
        u32 flow_count;
        u32 rx_batched;
        struct tun_pcpu_stats __percpu *pcpu_stats;    //网卡收发包统计数据
};

两个私有数据结构之间的关系

digraph tun{
    node [shape = plaintext]
    rankdir = LR
    tun_struct[label=<
            <TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0">
            <TR><TD BORDER="0" ALIGN="CENTER">struct tun_struct</TD></TR>
            <TR><TD ALIGN="LEFT" PORT="f0">struct tun_file *tfiles[MAX_TAP_QUEUES]</TD></TR>
            <TR><TD ALIGN="LEFT">unsigned int numqueues</TD></TR>
            <TR><TD ALIGN="CENTER">......</TD></TR>
            <TR><TD ALIGN="LEFT">struct net_device *dev</TD></TR>
            <TR><TD ALIGN="CENTER">......</TD></TR>
            <TR><TD ALIGN="LEFT">struct hlist_head flows[TUN_NUM_FLOW_ENTRIES]</TD></TR>
            <TR><TD ALIGN="CENTER">......</TD></TR>
            <TR><TD ALIGN="LEFT">struct tun_pcpu_stats __percpu *pcpu_status</TD></TR>
            </TABLE>>]
    tun_file[label=<
            <TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0">
            <TR><TD BORDER="0" ALIGN="CENTER">struct tun_file</TD></TR>
            <TR><TD ALIGN="LEFT" PORT="f0">struct sock sk</TD></TR>
            <TR><TD ALIGN="LEFT">struct socket socket</TD></TR>
            <TR><TD ALIGN="LEFT">socket_wq wq</TD></TR>
            <TR><TD ALIGN="LEFT">struct tun_struct *tun</TD></TR>
            <TR><TD ALIGN="CENTER">......</TD></TR>
            <TR><TD ALIGN="LEFT">struct tun_struct *detached</TD></TR>
            <TR><TD ALIGN="LEFT">struct skb_array tx_array</TD></TR>
            </TABLE>>]
    tun_struct:f0 -> tun_file:f0
}

模块注册

static int __init tun_init(void)
{
        int ret = 0;

        pr_info("%s, %s\n", DRV_DESCRIPTION, DRV_VERSION);

        ret = rtnl_link_register(&tun_link_ops);                          //注册netlink创建网卡的接口，当前应该没有通过这个创建
        if (ret) {
                pr_err("Can't register link_ops\n");
                goto err_linkops;
        }

        ret = misc_register(&tun_miscdev);        //注册字符设备，看代码用户态通过字符设备的ioctl接口创建网卡。
        if (ret) {
                pr_err("Can't register misc device %d\n", TUN_MINOR);
                goto err_misc;
        }

        register_netdevice_notifier(&tun_notifier_block);
        return  0;
err_misc:
        rtnl_link_unregister(&tun_link_ops);
err_linkops:
        return ret;
}

打开字符设备

static int tun_chr_open(struct inode *inode, struct file * file)
{       
        struct net *net = current->nsproxy->net_ns;
        struct tun_file *tfile;

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

        tfile = (struct tun_file *)sk_alloc(net, AF_UNSPEC, GFP_KERNEL,
                                            &tun_proto, 0); //创建字符文件的私有数据结构，该结构用来缓存skb及当有数据时唤醒读进程
        if (!tfile)
                return -ENOMEM;
        RCU_INIT_POINTER(tfile->tun, NULL);
        tfile->flags = 0;
        tfile->ifindex = 0;

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

        tfile->socket.file = file;
        tfile->socket.ops = &tun_socket_ops;            //vhost-net会使用这个调用发送和接受网卡数据。

        sock_init_data(&tfile->socket, &tfile->sk);     //初始化sk 和socket变量，

        tfile->sk.sk_write_space = tun_sock_write_space;
        tfile->sk.sk_sndbuf = INT_MAX;

        file->private_data = tfile;
        INIT_LIST_HEAD(&tfile->next);

        sock_set_flag(&tfile->sk, SOCK_ZEROCOPY);

        return 0;
}

通过 ioctl设置字符设备对应的网卡设备。

static long __tun_chr_ioctl(struct file *file, unsigned int cmd,
                            unsigned long arg, int ifreq_len)
{
......
       if (cmd == TUNSETIFF) {
                ret = -EEXIST;
                if (tun)
                        goto unlock;

                ifr.ifr_name[IFNAMSIZ-1] = '\0';

                ret = tun_set_iff(sock_net(&tfile->sk), file, &ifr); //设置关联网卡

                if (ret)
                        goto unlock;

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

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) {  
                if (ifr->ifr_flags & IFF_TUN_EXCL)
                        return -EBUSY;
                if ((ifr->ifr_flags & IFF_TUN) && dev->netdev_ops == &tun_netdev_ops)
                        tun = netdev_priv(dev);
                else if ((ifr->ifr_flags & IFF_TAP) && dev->netdev_ops == &tap_netdev_ops)
                        tun = netdev_priv(dev);
                else
                        return -EINVAL;

                if (!!(ifr->ifr_flags & IFF_MULTI_QUEUE) !=
                    !!(tun->flags & IFF_MULTI_QUEUE))
                        return -EINVAL;

                if (tun_not_capable(tun))
                        return -EPERM;
                err = security_tun_dev_open(tun->security);
                if (err < 0)
                        return err;

                err = tun_attach(tun, file, ifr->ifr_flags & IFF_NOFILTER); // 将当前文件的私有数据结构和网卡的私有数据结构关联。将tfile 存入tun结构的tfiles数组中
                if (err < 0)
                        return err;

                if (tun->flags & IFF_MULTI_QUEUE &&
                    (tun->numqueues + tun->numdisabled > 1)) {
                        /* One or more queue has already been attached, no need
                         * to initialize the device again.
                         */
                        return 0;
                }
        }
        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;
                err = security_tun_dev_create();
                if (err < 0)
                        return err;

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

                if (*ifr->ifr_name)
                        name = ifr->ifr_name;

                dev = alloc_netdev_mqs(sizeof(struct tun_struct), name,
                                       NET_NAME_UNKNOWN, tun_setup, queues,
                                       queues); //如果网卡设备不存在则创建网卡设备

                if (!dev)
                        return -ENOMEM;

                dev_net_set(dev, net);
                dev->rtnl_link_ops = &tun_link_ops;
                dev->ifindex = tfile->ifindex;
                dev->sysfs_groups[0] = &tun_attr_group;

                tun = netdev_priv(dev);
                tun->dev = dev;
                tun->flags = flags;
                tun->txflt.count = 0;
                tun->vnet_hdr_sz = sizeof(struct virtio_net_hdr);

                tun->align = NET_SKB_PAD;
                tun->filter_attached = false;
                tun->sndbuf = tfile->socket.sk->sk_sndbuf;
                tun->rx_batched = 0;

                tun->pcpu_stats = netdev_alloc_pcpu_stats(struct tun_pcpu_stats);
                if (!tun->pcpu_stats) {
                        err = -ENOMEM;
                        goto err_free_dev;
                }

                spin_lock_init(&tun->lock);

                err = security_tun_dev_alloc_security(&tun->security);
                if (err < 0)
                        goto err_free_stat;

                tun_net_init(dev);
                tun_flow_init(tun);

                dev->hw_features = NETIF_F_SG | NETIF_F_FRAGLIST |
                                   TUN_USER_FEATURES | NETIF_F_HW_VLAN_CTAG_TX |
                                   NETIF_F_HW_VLAN_STAG_TX;
                dev->features = dev->hw_features | NETIF_F_LLTX;
                dev->vlan_features = dev->features &
                                     ~(NETIF_F_HW_VLAN_CTAG_TX |
                                       NETIF_F_HW_VLAN_STAG_TX);

                INIT_LIST_HEAD(&tun->disabled);    //上面所有的步骤都是在初始化网卡和网卡的私有数据结构tun
                err = tun_attach(tun, file, false); //将当前文件的私有数据结构和网卡的私有数据结构关联。将tfile 存入tun结构的tfiles数组中
                if (err < 0)
                        goto err_free_flow;

                err = register_netdevice(tun->dev);
                if (err < 0)
                        goto err_detach;
        }

        netif_carrier_on(tun->dev);

        tun_debug(KERN_INFO, tun, "tun_set_iff\n");

        tun->flags = (tun->flags & ~TUN_FEATURES) |
                (ifr->ifr_flags & TUN_FEATURES);

        /* Make sure persistent devices do not get stuck in
         * xoff state.
         */
        if (netif_running(tun->dev))
                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_stat:
        free_percpu(tun->pcpu_stats);
err_free_dev:
        free_netdev(dev);
        return err;
}

至此，tun设备 已经创建完成。

通过tun设备发送数据。
发送函数是tun_chr_write_iter

static ssize_t tun_chr_write_iter(struct kiocb *iocb, struct iov_iter *from)
{
        struct file *file = iocb->ki_filp;
        struct tun_struct *tun = tun_get(file);
        struct tun_file *tfile = file->private_data;
        ssize_t result;

        if (!tun)
                return -EBADFD;

        result = tun_get_user(tun, tfile, NULL, from,
                              file->f_flags & O_NONBLOCK, false);   //获取用户态发送过来的skb结构，然后调用netif_rx_ni 收包

        tun_put(tun);
        return result;
}

tun_get_user函数 实体

static ssize_t tun_get_user(struct tun_struct *tun, struct tun_file *tfile,
                            void *msg_control, struct iov_iter *from,
                            int noblock, bool more)
{
......
        skb = tun_alloc_skb(tfile, align, copylen, linear, noblock);
        if (IS_ERR(skb)) {
                if (PTR_ERR(skb) != -EAGAIN)
                        this_cpu_inc(tun->pcpu_stats->rx_dropped);
                return PTR_ERR(skb);
        }

        if (zerocopy)
                err = zerocopy_sg_from_iter(skb, from);
        else
                err = skb_copy_datagram_from_iter(skb, 0, from, len);   //创建并获取数据
......
#ifndef CONFIG_4KSTACKS
        tun_rx_batched(tun, tfile, skb, more);  //数据批量上送协议栈
#else
        netif_rx_ni(skb);       //数据上送协议栈
#endif

        stats = get_cpu_ptr(tun->pcpu_stats);
        u64_stats_update_begin(&stats->syncp);
        stats->rx_packets++;
        stats->rx_bytes += len;
        u64_stats_update_end(&stats->syncp);
        put_cpu_ptr(stats);

        tun_flow_update(tun, rxhash, tfile);
        return total_len;
}

通过tun 设备收数据包
网卡设备最终调用tun_net_xmit函数发送数据包

static netdev_tx_t tun_net_xmit(struct sk_buff *skb, struct net_device *dev)
{
        struct tun_struct *tun = netdev_priv(dev);
        int txq = skb->queue_mapping;
        struct tun_file *tfile;
        u32 numqueues = 0;

        rcu_read_lock();
        tfile = rcu_dereference(tun->tfiles[txq]);//获取网卡关联的文件私有数据结构。
        numqueues = ACCESS_ONCE(tun->numqueues);

        /* Drop packet if interface is not attached */
        if (txq >= numqueues)
                goto drop;
......
        if (skb_array_produce(&tfile->tx_array, skb))   //将数据存放到文件私有数据结构的缓冲区内
                goto drop;

        /* Notify and wake up reader process */
        if (tfile->flags & TUN_FASYNC)
                kill_fasync(&tfile->fasync, SIGIO, POLL_IN);
        tfile->socket.sk->sk_data_ready(tfile->socket.sk);     //唤醒读文件阻塞的进程

        rcu_read_unlock();
        return NETDEV_TX_OK;

drop:
        this_cpu_inc(tun->pcpu_stats->tx_dropped);
        skb_tx_error(skb);
        kfree_skb(skb);
        rcu_read_unlock();
        return NET_XMIT_DROP;
}

文件读取数据函数

static ssize_t tun_chr_read_iter(struct kiocb *iocb, struct iov_iter *to)
{
        struct file *file = iocb->ki_filp;
        struct tun_file *tfile = file->private_data;
        struct tun_struct *tun = __tun_get(tfile);
        ssize_t len = iov_iter_count(to), ret;

        if (!tun)
                return -EBADFD;
        ret = tun_do_read(tun, tfile, to, file->f_flags & O_NONBLOCK, NULL);    //读取文件缓冲区的数据
        ret = min_t(ssize_t, ret, len);
        if (ret > 0)
                iocb->ki_pos = ret;
        tun_put(tun);
        return ret;
}

tun_do_read函数实体

static ssize_t tun_do_read(struct tun_struct *tun, struct tun_file *tfile,
                           struct iov_iter *to,
                           int noblock, struct sk_buff *skb)
{
        ssize_t ret;
        int err;

        tun_debug(KERN_INFO, tun, "tun_do_read\n");

        if (!iov_iter_count(to))
                return 0;

        if (!skb) {
                /* Read frames from ring */
                skb = tun_ring_recv(tfile, noblock, &err); //读取缓冲区的数据
                if (!skb)
                        return err;
        }

        ret = tun_put_user(tun, tfile, skb, to);        //将数据存放到用户态进程内存中
        if (unlikely(ret < 0))
                kfree_skb(skb);
        else
                consume_skb(skb);

        return ret;
}

tun_ring_recv函数实体

static struct sk_buff *tun_ring_recv(struct tun_file *tfile, int noblock,
                                     int *err)
{
        DECLARE_WAITQUEUE(wait, current);
        struct sk_buff *skb = NULL;
        int error = 0;

        skb = skb_array_consume(&tfile->tx_array);  //如果缓冲区里面有skb，获取skb
        if (skb)
                goto out;
        if (noblock) {
                error = -EAGAIN;
                goto out;
        }

        add_wait_queue(&tfile->wq.wait, &wait);
        current->state = TASK_INTERRUPTIBLE;    //如果缓冲区没有skb，将进程设置为可中断等待状态

        while (1) {
                skb = skb_array_consume(&tfile->tx_array);
                if (skb)
                        break;
                if (signal_pending(current)) {
                        error = -ERESTARTSYS;
                        break;
                }
                if (tfile->socket.sk->sk_shutdown & RCV_SHUTDOWN) {
                        error = -EFAULT;
                        break;
                }

                schedule();                     //切换到别的进程执行。等待直到缓冲区中有skb
        }

        current->state = TASK_RUNNING;
        remove_wait_queue(&tfile->wq.wait, &wait);

out:
        *err = error;
        return skb;                             //返回skb
}

至此，tun/tap设备的收发包过程就已经清楚了。
tun/tap 设备在做虚拟机backend时，如果有vhost-net，还有另外一条收发包路径，等分析vhost-net我在细说

LOOPBACK 回环网卡私有数据结构
该网卡没有私有数据结构

内核模块注册

struct pernet_operations __net_initdata loopback_net_ops = {
        .init = loopback_net_init,
};

在网络命令空间中每个网络命名空间必须有一个lo网卡，因此新创建的命令空间需要先运行 loopback_net_init函数给当前命名空间创建 lo网卡

网卡创建

static __net_init int loopback_net_init(struct net *net)
{
        struct net_device *dev;
        int err;

        err = -ENOMEM;
        dev = alloc_netdev(0, "lo", NET_NAME_UNKNOWN, loopback_setup);//创建网卡
        if (!dev)
                goto out;

        dev_net_set(dev, net);//设置网卡所属命令空间
        err = register_netdev(dev);//注册网卡
        if (err)
                goto out_free_netdev;

        BUG_ON(dev->ifindex != LOOPBACK_IFINDEX); //如果环回网卡不是第一块网卡，则报错
        net->loopback_dev = dev; //设置当前命名空间的环回网卡
        return 0;

out_free_netdev:
        free_netdev(dev);
out:
        if (net_eq(net, &init_net))
                panic("loopback: Failed to register netdevice: %d\n", err);
        return err;
}

初始化网卡，及环回网卡操作函数

static const struct net_device_ops loopback_ops = {
        .ndo_init        = loopback_dev_init,
        .ndo_start_xmit  = loopback_xmit,  //网卡发送函数
        .ndo_get_stats64 = loopback_get_stats64,
        .ndo_set_mac_address = eth_mac_addr,
};

/* The loopback device is special. There is only one instance
 * per network namespace.
 */
static void loopback_setup(struct net_device *dev)
{
        dev->mtu                = 64 * 1024;
        dev->hard_header_len    = ETH_HLEN;     /* 14   */
        dev->min_header_len     = ETH_HLEN;     /* 14   */
        dev->addr_len           = ETH_ALEN;     /* 6    */
        dev->type               = ARPHRD_LOOPBACK;      /* 0x0001*/
        dev->flags              = IFF_LOOPBACK;
        dev->priv_flags         |= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE;
        netif_keep_dst(dev);
        dev->hw_features        = NETIF_F_GSO_SOFTWARE;
        dev->features           = NETIF_F_SG | NETIF_F_FRAGLIST
                | NETIF_F_GSO_SOFTWARE
                | NETIF_F_HW_CSUM
                | NETIF_F_RXCSUM
                | NETIF_F_SCTP_CRC
                | NETIF_F_HIGHDMA
                | NETIF_F_LLTX
                | NETIF_F_NETNS_LOCAL
                | NETIF_F_VLAN_CHALLENGED
                | NETIF_F_LOOPBACK;
        dev->ethtool_ops        = &loopback_ethtool_ops;
        dev->header_ops         = &eth_header_ops;
        dev->netdev_ops         = &loopback_ops; //设置网卡操作函数
        dev->needs_free_netdev  = true;
        dev->priv_destructor    = loopback_dev_free;
}

网卡发送函数

static netdev_tx_t loopback_xmit(struct sk_buff *skb,
                                 struct net_device *dev)
{
        struct pcpu_lstats *lb_stats;
        int len;

        skb_tx_timestamp(skb);
        skb_orphan(skb);

        /* Before queueing this packet to netif_rx(),
         * make sure dst is refcounted.
         */
        skb_dst_force(skb);

        skb->protocol = eth_type_trans(skb, dev); //获取数据包类型，设置数据包接受网卡

        /* it's OK to use per_cpu_ptr() because BHs are off */
        lb_stats = this_cpu_ptr(dev->lstats);

        len = skb->len;
        if (likely(netif_rx(skb) == NET_RX_SUCCESS)) {  //通过netif_rx将数据包上送到协议栈
                u64_stats_update_begin(&lb_stats->syncp);
                lb_stats->bytes += len;
                lb_stats->packets++;
                u64_stats_update_end(&lb_stats->syncp);
        }

        return NETDEV_TX_OK;
}

loopback网卡，是linux 设备中的第一个网卡，在本机发往本地任何网卡IP的数据包都是走lo网卡。

VETH 类型网卡私有数据结构

struct veth_priv {
    struct net_device  __rcu *peer;
    atomic64_t      dropped;
    unsigned        requested_headromm;
}

veth_link_ops结构体实例

static struct rtnl_link_ops veth_link_ops ={
    .kind           = DRV_NAME,                 //虚拟网卡名字
    .priv_size      = sizeof(struct veth_priv), //虚拟网卡private data 长度
    .setup          = veth_setup,               //在创建虚拟网卡时调用
    .validate       = veth_validate,            //检查用户态传过来参数是否合法
    .newlink        = veth_newlink,             //根据用户态参数设置网卡 
    .dellink        = veth_dellink,             //删除网卡时调用，用于释放资源
    .policy         = veth_policy,              //没有跟踪用法，不影响逻辑
    .maxtype        = VETH_INFO_MAX,            //没有跟踪用法，不影响逻辑
    .get_link_net   = veth_get_link_net,        //获取网卡所在的网络命令空间
};

内核模块注册

static __init int veth_init(void)
{
    return rtnl_link_register(&veth_link_ops); //注册veth_link_ops结构，在用户态通过netlink，创建这种类型的虚拟网卡
}

创建虚拟网卡 逻辑
用户态通过 netlink 通知创建虚拟网卡，创建时先调用 veth_setup 函数 再调用 veth_newlink函数
veth_setup 函数

static void veth_setup(struct net_device *dev)
{
    ether_setup(dev);

    dev->priv_flags &= ~IFF_TX_SKB_SHARING;
    dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
    dev->priv_flags |= IFF_NO_QUEUE;
    dev->priv_flags |= IFF_PHONY_HEADROOM;

    dev->netdev_ops = &veth_netdev_ops;   //设置网卡处理函数 发送函数是 veth_xmit 这个函数跟数据流有关系。
    dev->ethtool_ops = &veth_ethtool_ops; //ethtool 命令通过ioctl获取网卡信息
    dev->features |= NETIF_F_LLTX;
    dev->features |= VETH_FEATURES;
    dev->vlan_features = dev->features &
                        ~(NETIF_F_HW_VLAN_CTAG_TX |
                        NETIF_F_HW_VLAN_STAG_TX |
                        NETIF_F_HW_VLAN_CTAG_RX |
                        NETIF_F_HW_VLAN_STAG_RX);
    dev->needs_free_netdev = true;
    dev->priv_destructor = veth_dev_free;
    dev->max_mtu = ETH_MAX_MTU;

    dev->hw_features = VETH_FEATURES;
    dev->hw_enc_features = VETH_FEATURES;
    dev->mpls_features = NETIF_F_HW_CSUM | NETIF_F_GSO_SOFTWARE;
    }

veth_newlink 函数 主要逻辑如下

static int veth_newlink(struct net *src_net, struct net_device *dev,
                        struct nlattr *tb[], struct nlattr *data[],
                        struct netlink_ext_ack *extack)
{
    .......
    peer = rtnl_create_link(net, ifname, name_assign_type,
                                &veth_link_ops, tbp); //创建 配对网卡
    .......
    priv = netdev_priv(dev);
    rcu_assign_pointer(priv->peer, peer); //将private 数据结构中的 peer 设置为对端网卡

    priv = netdev_priv(peer);
    rcu_assign_pointer(priv->peer, dev); //将private 数据结构中的 peer 设置为对端网卡。
    return 0;

}

到这里网卡 创建完成。接下来是收发数据包。
发包流程
在 veth_setup 函数中我们看到 veth_xmit 是网卡发包函数。
veth_xmit 函数体如下

static netdev_tx_t veth_xmit(struct sk_buff *skb, struct net_device *dev)
{       
    struct veth_priv *priv = netdev_priv(dev);
    struct net_device *rcv;
    int length = skb->len;

    rcu_read_lock();
    rcv = rcu_dereference(priv->peer); //获取对端设备。
    if (unlikely(!rcv)) {
        kfree_skb(skb);
        goto drop;
    }

    if (likely(dev_forward_skb(rcv, skb) == NET_RX_SUCCESS)) {  //发送数据
        struct pcpu_vstats *stats = this_cpu_ptr(dev->vstats); //统计发送成功的数据

        u64_stats_update_begin(&stats->syncp);
        stats->bytes += length;
         stats->packets++;
        u64_stats_update_end(&stats->syncp);
    } else {
drop:
        atomic64_inc(&priv->dropped);   //统计发送失败的数据
    }
    rcu_read_unlock();
    return NETDEV_TX_OK;
}

dev_forward_skb 函数体

int dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
{
    return __dev_forward_skb(dev, skb) ?: netif_rx_internal(skb); //通过__dev_forward_skb设置skb ，通过netif_rx_internal 将数据上送到协议栈
}
EXPORT_SYMBOL_GPL(dev_forward_skb);

__dev_forward_skb 函数体

int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb)
{
    int ret = ____dev_forward_skb(dev, skb);

    if (likely(!ret)) {
        skb->protocol = eth_type_trans(skb, dev); //获取以太网以上的网络协议，将收包网卡设置dev
        skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
    }

    return ret;
}
EXPORT_SYMBOL_GPL(__dev_forward_skb);

收报流程。收报流程在发包流程中可以看到，在对端网卡发包时，通过调用netif_rx_internal函数将数据包上送到协议栈，之后的处理流程就是网卡的收包流程