Linux 网络子系统

今天记录一下Linux网络子系统相关的东西。

因为感觉对这一块还是有一个很大的空白，这件事情太可怕了。

摘抄多份博客进行总结一下Linux网络子系统的相关东西。

一. Linux网络子系统体系结构

　　Linux 网络体系结构由如下图抽象的形容一下

1 . 用户空间：-----> 应用层

2 . 内核空间：-----> 系统调用接口： 主要指socket 系统调用

　　　　　　 -----> 协议无关接口： 实现一组基于socket的通用函数访问各种不同的协议

　　　　　　　-----> 网络协议： 　　udp, tcp 协议

　　　　　　　-----> 设备无关接口： 将协议与各种网络设备驱动连接在一起。

　　　　　　　-----> 设备驱动： 　　网络体系结构的最底层部分是负责管理物理网络设备的设备驱动层

3 . 硬件： 网络物理设备。

　　　 从上往下，形成Linux网络子系统。

二. 重要的头文件以及数据结构介绍

    重要的头文件:include/linux/netdevice.h

    这里面有个网络子系统的核心数据结构：net_device

net_device

        这里面包含了网络设备的各种属性,主要有如下重要属性：

struct net_device
{
     char   name[IFNAMSIZ];
     // 这是设备的名称，包含一个%d格式串，设备注册时，
     // 用一个数替换它形成一个新的名称，分配的编号从零开始

     //...
     unsigned long       state;
     //记录了设备的状态，是否激活是否是有效是否没有载波等等

     unsigned int        irq;
     /* device IRQ number  中断号  */
     unsigned int        mtu;
     /* interface MTU value  最大传输单元，默认1500   */
               unsigned char       *dev_addr;
     /* hw address, (before bcast
               because most packets are
               unicast) */
     //......还有很多相关的属性。
     //关于网络设备的操作结构体
     const struct net_device_ops *netdev_ops;
     const struct ethtool_ops *ethtool_ops;

}

#define alloc_netdev(sizeof_priv, name, setup) \
          alloc_netdev_mqs(sizeof_priv, name, setup, 1, 1)\
         /*  分配一个net_device结构体可以用上面这个宏函数进行分配
                其实最终调用是调用了alloc_netdev_mqs 函数*/
         /*  其中，参数sizeof_priv 表示网卡设备的私有数据大小，
                name指定网卡设备名称，setup指定网卡设备初始化回调函数  */ 

//对于不同的网卡设备，kernel提供了更直接的分配函数，
//例如以太网卡，可用用下面的宏函数进行分配：
//include/linux/etherdevice.h
#define alloc_etherdev(sizeof_priv) alloc_etherdev_mq(sizeof_priv, 1)
#define alloc_etherdev_mq(sizeof_priv, count) alloc_etherdev_mqs(sizeof_priv, count, count)
//其实最终调用是alloc_etherdev_mqs

//....
//其实这个函数只是做了简单的封装  net/ethernet/eth.c
struct net_device *alloc_etherdev_mqs(int sizeof_priv, unsigned int txqs,
                      unsigned int rxqs)
{
    return alloc_netdev_mqs(sizeof_priv, "eth%d", ether_setup, txqs, rxqs);
}
EXPORT_SYMBOL(alloc_etherdev_mqs);
//最终调用还是alloc_netdev_mqs 只不过名字是eth开头，%d会在后面解析出来。

//.......
//ether_setup 函数，以太网初始化函数    net/ethernet/eth.c
/**
 * ether_setup - setup Ethernet network device
 * @dev: network device
 * Fill in the fields of the device structure with Ethernet-generic values.
 */
void ether_setup(struct net_device *dev)
{
    dev->header_ops     = &eth_header_ops;
    dev->type       = ARPHRD_ETHER;
    dev->hard_header_len    = ETH_HLEN;
    dev->mtu        = ETH_DATA_LEN;
    dev->addr_len       = ETH_ALEN;
    dev->tx_queue_len   = 1000; /* Ethernet wants good queues */
    dev->flags      = IFF_BROADCAST|IFF_MULTICAST;
    dev->priv_flags     |= IFF_TX_SKB_SHARING;                                  

    memset(dev->broadcast, 0xFF, ETH_ALEN);                                     

}
EXPORT_SYMBOL(ether_setup);                                                     

---

struct net_device_ops

    和字符设备有一定的相似之处，网络设备也有相关的操作函数。
    他包含在net_device 结构体中的struct net_device_ops。
    他的原型如下：

struct net_device_ops {
    int         (*ndo_init)(struct net_device *dev);
                /* 该函数将在设备注册时，
                调用(即调用register_netdev()时)来做一些基本的初始化工作。 */
    void        (*ndo_uninit)(struct net_device *dev);
    int         (*ndo_open)(struct net_device *dev);
                /* 该函数在网络设备被激活变为up状态时被调用  */
    int         (*ndo_stop)(struct net_device *dev);
                /* 变为down状态时被调用  */
    netdev_tx_t     (*ndo_start_xmit) (struct sk_buff *skb,
                           struct net_device *dev);
                    /* 当上层协议需要发送数据时，调用该函数
                    需要返回NETDEV_TX_OK 或NET_TX_BUSY来确认结果 */
    u16             (*ndo_select_queue)(struct net_device *dev,
                            struct sk_buff *skb);
                    /* 呼叫然后决定哪个队列当设备支持多重传输队列的时候 */
    void            (*ndo_change_rx_flags)(struct net_device *dev,
                               int flags);
                    /* 调用这个函数允许设备接收器更改配置当运行多路传输的时候  */
    void            (*ndo_set_rx_mode)(struct net_device *dev);
                    /* 当调用这个函数改变地址过滤
                    如果驱动没有设置地址过滤，那个这个标志要设置为IFF_UNICAST_FLT    */
    int             (*ndo_set_mac_address)(struct net_device *dev,
                               void *addr);
                    /* 调用设置MAC地址  */
    int             (*ndo_validate_addr)(struct net_device *dev);
                    /* 测试多媒体访问地址是否有效   */
    int             (*ndo_do_ioctl)(struct net_device *dev,
                            struct ifreq *ifr, int cmd);
                    /* 当用户请求一个ioctl,如果ioctl没有相对应的接口函数，则返回not supported error code    */
    int             (*ndo_set_config)(struct net_device *dev,
                              struct ifmap *map);
                    /* 用它设置网络设备总线接口参数
                    保留这个接口的原因是因为新的设备要用PCI为了低水平的管理*/
    int             (*ndo_change_mtu)(struct net_device *dev,
                          int new_mtu);
                    /*  使用这个函数该表最大传输单元，
                    如果没有定义，那么任何请求改变MTU的请求都会报错 */
    int             (*ndo_neigh_setup)(struct net_device *dev,
                           struct neigh_parms *);

    void            (*ndo_tx_timeout) (struct net_device *dev);
                    /* 当传送器没有任何操作超时调用   */
    struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
                             struct rtnl_link_stats64 *storage);
    struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
                    /*  上面两个函数必须定义其中一个，这是用户想获取帮助的所调用的 */         

    void            (*ndo_vlan_rx_add_vid)(struct net_device *dev,
                               unsigned short vid);
                    /* 当设备支持VLAN过滤的时候，这个函数在一个VLAN ID 被注册时候调用  */
    void            (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
                                unsigned short vid);
                    /* 当设备支持VLAN过滤的时候，这个函数在一个VLAN ID 被注销时候调用   */
#ifdef CONFIG_NET_POLL_CONTROLLER
    void            (*ndo_poll_controller)(struct net_device *dev);

    int             (*ndo_netpoll_setup)(struct net_device *dev,
                             struct netpoll_info *info);
    void            (*ndo_netpoll_cleanup)(struct net_device *dev);
#endif
                /* SR-IOV management functions */
    int         (*ndo_set_vf_mac)(struct net_device *dev,
                          int queue, u8 *mac);
    int         (*ndo_set_vf_vlan)(struct net_device *dev,
                           int queue, u16 vlan, u8 qos);
    int         (*ndo_set_vf_tx_rate)(struct net_device *dev,
                              int vf, int rate);
    int         (*ndo_set_vf_spoofchk)(struct net_device *dev,
                               int vf, bool setting);
    int         (*ndo_get_vf_config)(struct net_device *dev,
                             int vf,
                             struct ifla_vf_info *ivf);
    int         (*ndo_set_vf_port)(struct net_device *dev,
                           int vf,
                           struct nlattr *port[]);
    int         (*ndo_get_vf_port)(struct net_device *dev,
                           int vf, struct sk_buff *skb);
    int         (*ndo_setup_tc)(struct net_device *dev, u8 tc);
                /*  调用这个函数设置tc 数字关于net设备的传输类别
                        这个允许网络设备安全的管理队列  */
#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
    int         (*ndo_fcoe_enable)(struct net_device *dev);
                /*  当FCoE协议栈使用LLD,所以下面的设备需要配置或者初始化关于FCoE传输的加速。
                    这时就调用这个函数  */
    int         (*ndo_fcoe_disable)(struct net_device *dev);
                /*  与上面那个函数刚好相反  */
                /*   .........*/
    int         (*ndo_fcoe_ddp_setup)(struct net_device *dev,
                              u16 xid,
                              struct scatterlist *sgl , unsigned int sgc);
                /*  当FCoE初始化想初始一个IO因为有个可能的候选人为直接的数据放置，成功在这个IO执行PPD这个函数返回1， 失败返回0  */
    int         (*ndo_fcoe_ddp_done)(struct net_device *dev,
                             u16 xid);
                /*  当FCoE目标已经完成，这时候要释放这个资源以便下次请求这个资源   */
    int         (*ndo_fcoe_ddp_target)(struct net_device *dev,
                               u16 xid,
                               struct scatterlist *sgl,
                               unsigned int sgc);                               

#endif                                                                          

#if defined(CONFIG_LIBFCOE) || defined(CONFIG_LIBFCOE_MODULE)
#define NETDEV_FCOE_WWNN 0
#define NETDEV_FCOE_WWPN 1
    int         (*ndo_fcoe_get_wwn)(struct net_device *dev,
                            u64 *wwn, int type);
#endif                                                                          

#ifdef CONFIG_RFS_ACCEL
    int         (*ndo_rx_flow_steer)(struct net_device *dev,
                             const struct sk_buff *skb,
                             u16 rxq_index,
                             u32 flow_id);
                 /* 设置硬件过滤为RFS */
#endif
    int         (*ndo_add_slave)(struct net_device *dev,
                         struct net_device *slave_dev);
                 /* 添加一个网络设备的从设备 */
    int         (*ndo_del_slave)(struct net_device *dev,
                         struct net_device *slave_dev);
                 /* 删除  */
    u32         (*ndo_fix_features)(struct net_device *dev,
                            u32 features);
                 /* 调整请求特征标志通过设备专用的 约束，返回标志结果，不能改变设备的状态*/
    int         (*ndo_set_features)(struct net_device *dev,
                            u32 features);
                 /* 升级设备新的配置   */
};                                                                              

sk_buff

    sk_buff 在include/linux/skbuff.h 里面被声明

/**
 *  struct sk_buff - socket buffer
 *  @next: Next buffer in list
 *  @prev: Previous buffer in list
 *  @tstamp: Time we arrived
 *  @sk: Socket we are owned by
 *  @dev: Device we arrived on/are leaving by
 *  @cb: Control buffer. Free for use by every layer. Put private vars here
 *  @_skb_refdst: destination entry (with norefcount bit)
 *  @sp: the security path, used for xfrm
 *  @len: Length of actual data
 *  @data_len: Data length
 *  @mac_len: Length of link layer header
 *  @hdr_len: writable header length of cloned skb
 *  @csum: Checksum (must include start/offset pair)
 *  @csum_start: Offset from skb->head where checksumming should start
 *  @csum_offset: Offset from csum_start where checksum should be stored
 *  @priority: Packet queueing priority
 *  @local_df: allow local fragmentation
 *  @cloned: Head may be cloned (check refcnt to be sure)
 *  @ip_summed: Driver fed us an IP checksum
 *  @nohdr: Payload reference only, must not modify header
 *  @nfctinfo: Relationship of this skb to the connection
 *  @pkt_type: Packet class
 *  @fclone: skbuff clone status
 *  @ipvs_property: skbuff is owned by ipvs
 *  @peeked: this packet has been seen already, so stats have been
 *      done for it, don't do them again
 *  @nf_trace: netfilter packet trace flag
 *  @protocol: Packet protocol from driver
 *  @destructor: Destruct function
 *  @nfct: Associated connection, if any
 *  @nfct_reasm: netfilter conntrack re-assembly pointer
 *  @nf_bridge: Saved data about a bridged frame - see br_netfilter.c
 *  @skb_iif: ifindex of device we arrived on
 *  @tc_index: Traffic control index
 *  @tc_verd: traffic control verdict
 *  @rxhash: the packet hash computed on receive
 *  @queue_mapping: Queue mapping for multiqueue devices
 *  @ndisc_nodetype: router type (from link layer)
 *  @ooo_okay: allow the mapping of a socket to a queue to be changed
  *  @ndisc_nodetype: router type (from link layer)
 *  @ooo_okay: allow the mapping of a socket to a queue to be changed
 *  @l4_rxhash: indicate rxhash is a canonical 4-tuple hash over transport
 *      ports.
 *  @dma_cookie: a cookie to one of several possible DMA operations
 *      done by skb DMA functions
 *  @secmark: security marking
 *  @mark: Generic packet mark
 *  @dropcount: total number of sk_receive_queue overflows
 *  @vlan_tci: vlan tag control information
 *  @transport_header: Transport layer header
 *  @network_header: Network layer header
 *  @mac_header: Link layer header
 *  @tail: Tail pointer
 *  @end: End pointer
 *  @head: Head of buffer
 *  @data: Data head pointer
 *  @truesize: Buffer size
 *  @users: User count - see {datagram,tcp}.c
 */

//这个结构体里面所有的成员如上注释
//其中重要的有如下几个着重解释一下：
struct sk_buff
{
    /* These two members must be first. */
    struct sk_buff      *next;         /* 指向下一个的sk_buff  */
    struct sk_buff      *prev;         /* 指向前一个的sk_buff  */                                  

    struct sock *sk;                   /*  该sk_buff 拥有的套接字   */
    struct net_device  *dev;           /*  处理该包的设备 */

    __be16          protocol;          /*  该包所属的协议类型  */
    unsigned int        len,
                data_len;              /*  有效数据的长度以及数据总长度   */
    sk_buff_data_t      transport_header;      /* 指向传输层包头 */
    sk_buff_data_t      network_header;        /* 指向网络层包头 */
    sk_buff_data_t      mac_header;            /* 指向链路层包头 */
    /* These elements must be at the end, see alloc_skb() for details.  */
    sk_buff_data_t      tail;                  /* 有效数据的结束 */
    sk_buff_data_t      end;                   /* 分配空间的结束 */
    unsigned char       *head,                 /* 分配空间的开始 */
                *data;                         /* 有效数据的开始 */                                                 

}
//sk_buff中定义了4个指向数据包缓冲区不同位置的指针head、data、tail、end、
//.......
//sk_buff 的基本操作函数

static inline struct sk_buff *__dev_alloc_skb(unsigned int length,   <-------------|
                          gfp_t gfp_mask)                                          |
{                                                                                  |
    struct sk_buff *skb = alloc_skb(length + NET_SKB_PAD, gfp_mask);  ---          |
    if (likely(skb))                                                    |          |
        skb_reserve(skb, NET_SKB_PAD);                                  |          |
    return skb;                                                         |          |
}                                                                       |          |
                                                                        |          |
extern struct sk_buff *dev_alloc_skb(unsigned int length);              |          |
/*                                                                      |          |
struct sk_buff *dev_alloc_skb(unsigned int length)     //最开始位置     |          |
{                                                                       |          |
     * There is more code here than it seems:                           |          |
     * __dev_alloc_skb is an inline                                     |          |
     */                                                                 |          |
    return __dev_alloc_skb(length, GFP_ATOMIC);    --------------------------------                     |
}                                                                       |
EXPORT_SYMBOL(dev_alloc_skb);                                           |
*/              |                                                       |
                                                                        |
extern struct sk_buff *__netdev_alloc_skb(struct net_device *dev,       |
        unsigned int length, gfp_t gfp_mask);                           |
                                                                        |
                                                                        |
                                                                        |
extern struct sk_buff *__alloc_skb(unsigned int size,                   |
                   gfp_t priority, int fclone, int node);               |
static inline struct sk_buff *alloc_skb(unsigned int size,    <—————
                    gfp_t priority)
{
    return __alloc_skb(size, priority, 0, NUMA_NO_NODE);  -----
}                                                              |
//最终调用__alloc_skb进行申请一个sk_buff结构体                 |
//他的函数原型在net/core/skbuff.c                              |
/**                                                            |
 *  __alloc_skb -   allocate a network buffer     <____________|
 *  @size: size to allocate     长度
 *  @gfp_mask: allocation mask  掩码
 *  @fclone: allocate from fclone cache instead of head cache
 *      and allocate a cloned (child) skb
 *  @node: numa node to allocate memory on
 *
 *  Allocate a new &sk_buff. The returned buffer has no headroom and a
 *  tail room of size bytes. The object has a reference count of one.
 *  The return is the buffer. On a failure the return is %NULL.
 *
 *  Buffers may only be allocated from interrupts using a @gfp_mask of
 *  %GFP_ATOMIC.
 */
struct sk_buff *__alloc_skb(unsigned int size, gfp_t gfp_mask,
                int fclone, int node)
{
//......
}