OpenStack和SDNSDN系统运维专家

OVS 源码分析整理

2016-07-25  本文已影响6203人  NightCat

OVS 核心代码

OVS 架构


OVS 主要的数据结构


数据结构关系图

主要的数据结构和数据结构的参数

数据结构代码

vvport

/**
- struct vport - one port within a datapath
- @rcu: RCU callback head for deferred destruction.
- @dp: Datapath to which this port belongs.
- @upcall_portids: RCU protected 'struct vport_portids'.
- @port_no: Index into @dp's @ports array.
- @hash_node: Element in @dev_table hash table in vport.c.
- @dp_hash_node: Element in @datapath->ports hash table in datapath.c.
- @ops: Class structure.
- @percpu_stats: Points to per-CPU statistics used and maintained by vport
- @err_stats: Points to error statistics used and maintained by vport
 */
struct vport {  
    struct rcu_head rcu; // 一种锁机制  
    struct datapath *dp; // 网桥结构体指针,表示该端口是属于哪个网桥的  
    u32 upcall_portid; // Netlink端口收到的数据包时使用的端口id  
    u16 port_no; // 端口号,唯一标识该端口  
  
// 因为一个网桥上有多个端口,而这些端口都是用哈希链表来存储的,  
// 所以这是链表元素(里面没有数据,只有next和prev前驱后继指针,数据部分就是vport结构体中的其他成员)  
    struct hlist_node hash_node;   
    struct hlist_node dp_hash_node; // 这是网桥的哈希链表元素  
    const struct vport_ops *ops; // 这是端口结构体的操作函数指针结构体,结构体里面存放了很多操作函数的函数指针  

    struct pcpu_tstats __percpu *percpu_stats;// vport指向每个cpu的统计数据使用和维护  
  
    spinlock_t stats_lock; // 自旋锁,防止异步操作,保护下面的两个成员  
    struct vport_err_stats err_stats; // 错误状态(错误标识)指出错误vport使用和维护的统计数字   
    struct ovs_vport_stats offset_stats; // 添加到实际统计数据,部分原因是为了兼容  
};  

vport_parms

/**
- struct vport_parms - parameters for creating a new vport
 *
- @name: New vport's name.
- @type: New vport's type.
- @options: %OVS_VPORT_ATTR_OPTIONS attribute from Netlink message, %NULL if
- none was supplied.
- @dp: New vport's datapath.
- @port_no: New vport's port number.
 */
struct vport_parms {  
    const char *name; // 新端口的名字  
    enum ovs_vport_type type; // 新端口的类型(端口不仅仅只有一种类型,后面会分析到)   
    struct nlattr *options; // 这个没怎么用到过,好像是从Netlink消息中得到的OVS_VPORT_ATTR_OPTIONS属性  
  
    /* For ovs_vport_alloc(). */  
    struct datapath *dp; // 新的端口属于哪个网桥的  
    u16 port_no; // 新端口的端口号  
    u32 upcall_portid; // 和Netlink通信时使用的端口id  
};  

vport_ops

/**
- struct vport_ops - definition of a type of virtual port
 *
- @type: %OVS_VPORT_TYPE_* value for this type of virtual port.
- @create: Create a new vport configured as specified.  On success returns
- a new vport allocated with ovs_vport_alloc(), otherwise an ERR_PTR() value.
- @destroy: Destroys a vport.  Must call vport_free() on the vport but not
- before an RCU grace period has elapsed.
- @set_options: Modify the configuration of an existing vport.  May be %NULL
- if modification is not supported.
- @get_options: Appends vport-specific attributes for the configuration of an
- existing vport to a &struct sk_buff.  May be %NULL for a vport that does not
- have any configuration.
- @get_name: Get the device's name.
- @send: Send a packet on the device.  Returns the length of the packet sent,
- zero for dropped packets or negative for error.
- @get_egress_tun_info: Get the egress tunnel 5-tuple and other info for
- a packet.
 */

struct vport_ops {  
    enum ovs_vport_type type; // 端口的类型  

    // 新vport端口的创建函数和销毁端口的函数  
    struct vport *(*create)(const struct vport_parms *); // 根据指定的参数配置创建个新的vport,成功返回新端口指针  
    void (*destroy)(struct vport *); // 销毁端口函数  
  
    // 得到和设置option成员函数  
    int (*set_options)(struct vport *, struct nlattr *);  
    int (*get_options)(const struct vport *, struct sk_buff *);  
  
    // 得到端口名称和配置以及发送数据包函数     
    const char *(*get_name)(const struct vport *); //
    int (*send)(struct vport *, struct sk_buff *); // 发送数据包到设备上  
};  

vport_ops_list

/* List of statically compiled vport implementations.  Don't forget to also
- add yours to the list at the bottom of vport.h.
 */
static const struct vport_ops *vport_ops_list[] = {  
    &ovs_netdev_vport_ops,
    &ovs_internal_vport_ops,
    &ovs_geneve_vport_ops,
#if IS_ENABLED(CONFIG_NET_IPGRE_DEMUX)
    &ovs_gre_vport_ops,
    &ovs_gre64_vport_ops,
#endif
    &ovs_vxlan_vport_ops,
    &ovs_lisp_vport_ops,
};

datapath

struct datapath {  
    struct rcu_head rcu; // RCU调延迟破坏。  
    struct list_head list_node; // 网桥哈希链表元素,里面只有next和prev前驱后继指针,数据时该结构体其他成员  
  
    /* Flow table. */  
    struct flow_table __rcu *table;// 这是哈希流表,里面包含了哈希桶的地址指针。该哈希表受_rcu机制保护  
  
    /* Switch ports. */  
    struct hlist_head *ports;// 一个网桥有多个端口,这些端口都是用哈希链表来链接的  
  
    /* Stats. */  
    struct dp_stats_percpu __percpu *stats_percpu;  
  
#ifdef CONFIG_NET_NS  
    /* Network namespace ref. */  
    struct net *net;  
#endif  
};  

sw_flow_key

struct sw_flow_key {  
       // 这是隧道相关的变量  
    struct ovs_key_ipv4_tunnel tun_key;  /* Encapsulating tunnel key. */  
    struct {  
       // 包的优先级  
        u32 priority; // 包的优先级  
        u32 skb_mark; // 包的mark值  
        u16 in_port; // 包进入的端口号  
    } phy; // 这是包的物理层信息结构体提取到的  
    struct {  
        u8     src[ETH_ALEN]; // 源mac地址  
        u8     dst[ETH_ALEN]; // 目的mac地址  
        __be16 tci; // 这好像是局域网组号  
        __be16 type; // 包的类型,即:是IP包还是ARP包  
    } eth; // 这是包的二层帧头信息结构体提取到的   
    struct {  
        u8     proto; // 协议类型 TCP:6;UDP:17;ARP类型用低8位表示  
        u8     tos; // 服务类型  
        u8     ttl; // 生存时间,经过多少跳路由  
        u8     frag; // 一种OVS中特有的OVS_FRAG_TYPE_*.   
    } ip; // 这是包的三层IP头信息结构体提取到的  
       // 下面是共用体,有IPV4和IPV6两个结构,为了后期使用IPV6适应  
    union {  
        struct {  
            struct {  
                __be32 src; // 源IP地址  
                __be32 dst; // 目标IP地址  
            } addr; // IP中地址信息  
                        // 这又是个共用体,有ARP包和TCP包(包含UDP)两种  
            union {  
                struct {  
                    __be16 src; // 源端口,应用层发送数据的端口  
                    __be16 dst; // 目的端口,也是指应用层传输数据端口  
                } tp; // TCP(包含UDP)地址提取  
                struct {  
                    u8 sha[ETH_ALEN]; // ARP头中源Mac地址  
                    u8 tha[ETH_ALEN]; // ARP头中目的Mac地址  
                } arp;ARP头结构地址提取  
            };  
        } ipv4;  
               // 下面是IPV6的相关信息,基本和IPV4类似,这里不讲  
        struct {  
            struct {  
                struct in6_addr src;    /* IPv6 source address. */  
                struct in6_addr dst;    /* IPv6 destination address. */  
            } addr;  
            __be32 label;           /* IPv6 flow label. */  
            struct {  
                __be16 src;     /* TCP/UDP source port. */  
                __be16 dst;     /* TCP/UDP destination port. */  
            } tp;  
            struct {  
                struct in6_addr target; /* ND target address. */  
                u8 sll[ETH_ALEN];   /* ND source link layer address. */  
                u8 tll[ETH_ALEN];   /* ND target link layer address. */  
            } nd;  
        } ipv6;  
    };  
};  

flow_table

struct flow_table {  
    struct flex_array *buckets; //哈希桶地址指针  
    unsigned int count, n_buckets; // 哈希桶个数  
    struct rcu_head rcu; // rcu包含机制  
    struct list_head *mask_list; // struct sw_flow_mask链表头指针  
    int node_ver;  
    u32 hash_seed; //哈希算法需要的种子,后期匹配时要用到  
    bool keep_flows; //是否保留流表项  
};  

};

sw_flow

struct sw_flow {  
    struct rcu_head rcu; // rcu保护机制  
    struct hlist_node hash_node[2]; // 两个节点指针,用来链接作用,前驱后继指针  
    u32 hash; // hash值  
  
    struct sw_flow_key key; // 流表中的key值  
    struct sw_flow_key unmasked_key; // 也是流表中的key  
    struct sw_flow_mask *mask; // 要匹配的mask结构体  
    struct sw_flow_actions __rcu *sf_acts; // 相应的action动作  
  
    spinlock_t lock; // 保护机制自旋锁  
    unsigned long used; // 最后使用的时间  
    u64 packet_count; // 匹配过的数据包数量  
    u64 byte_count; // 匹配字节长度  
    u8 tcp_flags; // TCP标识  
};    

sw_flow_mask

struct sw_flow_mask {  
        int ref_count;  
        struct rcu_head rcu;  
        struct list_head list;// mask链表元素,因为mask结构是个双链表结构体  
        struct sw_flow_key_range range;// 操作范围结构体,因为key值中有些数据时不要用来匹配的  
        struct sw_flow_key key;// 要和数据包操作的key,将要被用来匹配的key值  
};  

datapath 模块


datapath 简介

datapath为 ovs内核模块,负责执行数据交换,也就是把从接收端口收到的数据包在流表中进行匹配,并执行匹配到的动作。

一个datapath可以对应多个vport,一个vport类似物理交换机的端口概念。一个datapth关联一个flow table,一个flow table包含多个条目,每个条目包括两个内容:一个match/key和一个action


datapath 代码

dp_init 代码

static int __init dp_init(void)
{
    int err;

    BUILD_BUG_ON(sizeof(struct ovs_skb_cb) > FIELD_SIZEOF(struct sk_buff, cb));

    pr_info("Open vSwitch switching datapath %s, built "__DATE__" "__TIME__"\n",
        VERSION);
    err = ovs_flow_init();//申请 flow_cache和 flow_stats_cache
    if (err)
        goto error;

    err = ovs_vport_init();//vport 数据结构初始化,申请 dev_table
    if (err)
        goto error_flow_exit;

    err = register_pernet_device(&ovs_net_ops);//注册网络名字空间设备
    if (err)
        goto error_vport_exit;

    err = register_netdevice_notifier(&ovs_dp_device_notifier);//注册设备通知事件
    if (err)
        goto error_netns_exit;

    err = dp_register_genl();//dp_register_genl 初始化 dp 相关的 netlink 的 family和ops
    if (err < 0)
        goto error_unreg_notifier;

    return 0;

error_unreg_notifier:  
    unregister_netdevice_notifier(&ovs_dp_device_notifier);
error_netns_exit:  
    unregister_pernet_device(&ovs_net_ops);
error_vport_exit:  
    ovs_vport_exit();
error_flow_exit:  
    ovs_flow_exit();
error:  
    return err;
}

vswitchd 模块


vswitchd 代码

set_program_name(argv)

设置程序名称、版本、编译日期等信息

proctitle_int(argh,argv)

复制出输入的参数列表到新的存储中,让argv指向这块内存【主要是为了后面的proctitle_set()函数准备】

service_start(&argc,&argv)

注册回调和服务管理器出现故障错误时操作的配置

remote=parse_options(argh,argv,&unixctl_path)

解析参数,其中unixctl_path存储unixctrl域的sock名,作为接受外部控制命令的渠道;而remote存储连接到ovsdb的信息,即连接到配置数据库的sock名

ovsrec_init()

数据表结构初始化,包括13张数据表

daemonize_start()

如果系统守护进程被配置了,启动系统守护进程,通过派生和在返回的子进程。父进程徘徊,直到
让子进程知道它完成启动成功(通过调用daemon_complete()),或者它没有启动(用非零退出
退出代码。

unixctl_server_create(unixctl_path,&unixctl)

创建一个unixctl_server(存放在unixctl),并监听在unixctl_path指定的punix路径,该路径作为ovs-appctl发送命令给ovsd的通道

unixctl_command_register

注册unixctl命令

bridge_init

从remote数据库获取配置信息,并初始化bridge

主循环
memory_run()

运行内存监视器,客户端调用memory_should_report()。此函数以及该模块的接口的剩余部分,仅被一个线程调用。

bridge_run

主要对网包进行完整处理过程。包括完成必要的配置更新【在配置更新中会从数据库中读取配置信息,生成必要的bridge和dp等数据结构】

ovsdb_idl_run(idl);

处理了一批从'IDL'数据库服务器的消息。这可能会导致IDL的内容发生变化。客户端可以检查与ovsdb_idl_get_seqno()。

system_stats_enable(false);

因为我们不运行system_stats的run()在这个进程中有多个OVS-vswitchd守护进程的现状,关闭系统自动统计信息收集。

bridge_init_ofproto(cfg)

初始化ofproto库。这仅需要执行一次,但配置设置之后它必须要做的。如果已经出现了初始化,bridge_init_ofproto()立即返回。

bridge_run__(void)

#######ofproto_run中的p->ofproto_class->run(p)上的run函数依次调用函数

可选调用较多,自行查看

#######connmr_run函数处理与控制器的周期性交互

以 PACKET_OUT消息为例,调用的是handle_packout 函数

首先调用ofputil_decode_packet_out()对of消息进行解析
调用ofconn_pktbuf_retrieve()获取payload信息
利用ofproto_class->packet_out()将网包发出
packet_out()
{   
    ofproto_dpif_execute_actions()
        {
        dpif_flow_stats_extract() 流状态提取
        xlate_actions()将ofpacts转化为dp的行动格式odp_actions
        调用dpif_execute()函数让dpif执行给定的action构建OVS_PACKET_CMD_EXECUTE netlink消息并发给datapath
        datapath中将对应调用ovs_packet_cmd_execute函数处理收到的nlmsg
        ovs_packet_cmd_execute的调用过程
        ovs_packet_cmd_execute()->ovs_execute_actions()->do_execute_actions()
        }
}
重新配置SSL

通过主循环每一次遍历,而不是只当数据库的变化,因为密钥和证书文件的内容可以更改在数据库不更改中。我们完成这些在bridge_reconfigure()之前,因为该功能可能会启动SSL连接之前做到这一点,因此需要SSL进行配置。

对all_bidge上的每个bridge的ofproto执行ofproto_run()
netdev_run()

如果打开了一些netted,则执行对应在netdev_classes上定义的每个netdev_class实体,调用它们的run()包括处理网卡注册的各个通知事件,获取网卡的最新的信息等

unixctl_server_run(unixctl)

从unixctl指定的server中获取来自ovs-appctl发出的命令数据,并执行对应的命令

循环等待事件处理

包括memory、bridge、unixctl_server、netted等事件,被poll_fd_wait()注册的最短时间

poll_block(void)

阻塞知道之前被poll_fd_wait()注册过的事件发生,或者等待时间超过poll_timer_wait()注册的最短时间

清理工作

退出bridge,关闭unixctl连接

动态过程分析


数据流流向


一般的数据包在 Linux网络协议中的流向为黑色箭头流向:网卡收到数据包后层层网上分析,最后离开内核态,把数据传送到用户态。
有 OVS时:数据流流向不同
(1)创网桥(ovs-vsctl add-br br0)
(2)绑网卡(ovs-vsctl add-port bro eth0 默认为 eth0)
数据流:
从网卡 eth0到 ovs 的 vport 进入OVS,根据 key值流表匹配
成功——>执行流表 action
失败——>upcall处理

添加网桥


1. 键入命令ovs-vsctl add-br testBR
2. 内核中的 openvswitch.ko 收到一个添加网桥的命令时候——即收到 OVS_DATAPATH_FAMILY通道的 OVS_DP_CMD_NEW命令。该命令绑定的回调函数为 ovs_dp_cmd_new
3. ovs_dp_cmd_new 函数除了初始化 dp 结构外,调用 new_vport 函数来生成新的 vport
4. new_vport 函数调用 ovs_vport_add()来尝试生成一个新的 vport
5. ovs_vport_add()函数会检查 vport 类型(通过 vport_ops_list[]数组),并调用相关的 create()函数来生成 vport 结构
6. 当dp是网络设备时(vport_netdev.c),最终由 ovs_vport_add()函数调用的是 netdev_create()【在 vport_ops_list的ovs_netdev_ops 中】
7. netdev_create()函数最关键的一步是注册了收到网包时的回调函数
8. err=netdev_rx_handler_register(netdev_vport->dev,netdev_frame_hook,vport);
9. 操作是将 netdev_vport->dev 收到网包时的相关数据由 netdev_frame_hook()函数来处理,都是些辅助处理,依次调用各处理函数,在 netdev_port_receive()【这里会进行数据包的拷贝,避免损坏】进入 ovs_vport_receive()回到 vport.c,从 ovs_dp_process_receive_packet()回到 datapath.c,进行统一处理
10. 流程:netdev_frame_hook()->netdev_port_receive->ovs_vport_receive->ovs_dp_process_received_packet()
11. net_port_receive()首先检测是否 skb 被共享,若是则得到 packet 的拷贝。
12. net_port_receive()其调用ovs_vport_receive(),检查包的校验和,然后交付给我们的vport通用层来处理。

netdev_rx_handler_register()
linux 内核实现的一个函数,为网络设备 dev 注册一个handler_frame_hook,rx_handle_data 指向的是handler_frame_hook 内存的区域,这个 handler 以后会被__netif_receive_skb()呼叫,就是说netdev_rx_handler_register(netdev_vport->dev,netdev_frame_hook,vport);在收到packet 后会调用 netdev_frame_hook 函数处理

收包处理


1.ovs_vport_receive_packets()调用ovs_flow_extract基于skb生成key值,并检查是否有错,然后调用ovs_dp_process_packet。交付给datapath处理
2.ovs_flow_tbl_lookup_stats。基于前面生成的key值进行流表查找,返回匹配的流表项,结构为sw_flow。 
3.若不存在匹配,则调用ovs_dp_upcall上传至userspace进行匹配。 (包括包和key都要上传) 
若存在匹配,则直接调用ovs_execute_actions执行对应的action,比如添加vlan头,转发到某个port等。

流表匹配


1. flow_lookup()查找对应的流表项
2. for 循环调用 rcu_dereference_ovs 对流表结构体中的 mask_list 成员遍历,找到对应的的 成员
3. flow=masked_flow_lookup()遍历进行下一级 hmap查找,找到为止
4. 进入 包含函数 ovs_flow_mask_key(&masked_key,unmasked,mask),将最开始提取的 Key 值和 mask 的 key 值进行“与”操作,结果存放在 masked_key 中,用来得到后面的 Hash 值
5. hash=flow_hash(&masked_key,key_start,key_end)key 值的匹配字段只有部分
6. ovs_vport_add()函数会检查 vport 类型(通过 vport_ops_list[]数组),并调用相关的 create()函数来生成 vport 结构
7. 可见,当 dp 时网络设备时(vport_netdev.c),最终由 ovs_vport_add()函数调用的是 netdev_create()【在 vport_ops_list的ovs_netdev_ops 中】
8. netdev_vport->dev 收到网包时的相关数据由 netdev_frame_hook()函数来处理,都是些辅助处理,依次调用各处理函数,在 netdev_port_receive()【这里会进行数据包的拷贝,避免损坏】进入 ovs_vport_receive()回到 vport.c,从 ovs_dp_process_receive_packet()回到 datapath.c,进行统一处理

upcall 消息处理


1. ovs_dp_upcall()首先调用 err=queue_userspace_packet()将信息排队发到用户空间去
2. dp_ifindex=get_dpifindex(dp)获取网卡设备索引号
3. 调整 VLAN的 MAC 地址头指针
4. 网络链路属性,如果不需要填充则调用此函数
5. len=upcall_msg_size(),获得 upcall 发送消息的大小
6. user_skb=genlmsg_new_unicast,创建一个新的 netlink 消息
7. upcall=genlmsg_put()增加一个新的 netlink 消息到 skb
8. err=genlmsg_unicast(),发送消息到用户空间去处理

相关内容


Linux RCU锁机制分析


RCU是linux的新型锁机制(RCU是在linux 2.6内核版本中开始正式使用)

传统读写锁rwlock运行机制

读锁(共享锁):若请求是读数据时,上读锁,多个读锁不排斥(即访问数据的读者上限未达到时,可以对数据区再上读锁),若请求是写数据时,不能马上上写锁,得等数据区的所有锁(包括读锁和写锁)都释放才能上写锁

写锁(独占锁):要操作的数据区上了写锁,不管什么请求都要等到数据区的写锁释放掉后才能上锁访问

RCU 锁机制——RCU(read\copy\update)对数据的读、复制、修改的保护锁机制

写数据:(1)不需读写锁那样等待所有锁释放【拷贝一份数据区的副本,在副本中修改,修改完后,用副本替代原来的数据区】(2)替换的时候需要读写锁上写锁那样,等到数据区上所有访问者退出后,才进行数据的替换
(3)RCU锁可以有多个写者,拷贝多份数据区数据,修改后,各个数据区陆续替换掉原数据区内容
读数据:不用上任何锁,几乎不需要等待(读写锁需要等写锁释放)就可以直接访问数据
,“几乎”,因为写数据中替换原数据,只需修改个指针,消耗的时间几乎不算

RCU 锁机制特性

• 允许多个读者和多个写者同时访问共享数据区内容
• 对多读少写的数据来说非常高效,可以减少 CPU 开销
• 写数据操作多了,就不如读写锁那么好了,因为RCU 对写数据开销大,需要拷贝数据,修改,等待替换

RCU 机制 API

rcu_read_lock();
• 这不是和上读写锁的那种上锁,这仅仅只是标识了临界区的开始位置。表明在临界区内不能阻塞和休眠,也不能让写者进行数据的替换(其实这功能远不止这些)。rcu _read_unlock()则是和上面rcu_read_lock()对应的,用来界定一个临界区(就是要用锁保护起来的数据区)。
synchronize_rcu();
• 当该函数被一个CPU调用时(一般是有写者替换数据时调用),而其他的CPU都在RCU保护的临界区读数据,那么synchronize_rcu()将会保证阻塞写者,直到所有其它读数据的CPU都退出临界区时,才中止阻塞,让写着开始替换数据。该函数作用就是保证在替换数据前,所有读数据的CPU能够安全的退出临界区。同样,还有个call_rcu()函数功能也是类似的。如果call_rcu()被一个CPU调用,而其他的CPU都在RCU保护的临界区内读数据,相应的RCU回调的调用将被推迟到其他读临界区数据的CPU全部安全退出后才执行(可以看linux内核源文件的注释,在Rcupdate.h文件中rcu_read_look()函数前面的注释)。
rcu_dereference();
• 获取在一个RCU保护的指针,指向RCU读端临界区。他的指针以后可能会被安全地解除引用。说到底就是一个RCU保护指针。
list_add_rcu();
• 往RCU保护的数据结构中添加一个数据节点进去。这个和一般的往链表中增加一个节点操作是类似的,唯一不同的是多了这条代码:rcu_assign_pointer(prev->next, new); 代码大概含义:分配指向一个新初始化的结构指针,将由RCU读端临界区被解除引用,返回指定的值。
list_for_each_entry_rcu();
• 这是个遍历RCU链表的操作,和一般的链表遍历差不多。不同点就是必须要进入RCU保护的CPU(即:调用了rcu_read_lock()函数的CPU)才能调用这个操作,可以和其他CPU共同遍历这个RCU链表。

Generic Netlink 通信机制


    +---------------------+      +---------------------+
      | (3) application "A" |      | (3) application "B" |
      +------+--------------+      +--------------+------+
             |                                    |
             \                                    /
              \                                  /
               |                                |
       +-------+--------------------------------+-------+
       |        :                               :       |   user-space
  =====+        :   (5)  Kernel socket API      :       +================
       |        :                               :       |   kernel-space
       +--------+-------------------------------+-------+
                |                               |
          +-----+-------------------------------+----+
          |        (1)  Netlink subsystem            |
          +---------------------+--------------------+
                                |
          +---------------------+--------------------+
          |       (2) Generic Netlink bus            |
          +--+--------------------------+-------+----+
             |                          |       |
     +-------+---------+                |       |
     |  (4) Controller |               /         \
     +-----------------+              /           \
                                      |           |
                   +------------------+--+     +--+------------------+
                   | (3) kernel user "X" |     | (3) kernel user "Y" |
                   +---------------------+     +---------------------+

(5)API向用户空间和内核空间分别提供接口。
Netlink子系统(1)是所有genl通信的基础。Netlink子系统中收到的所有Generic类型的netlink数据都被送到genl总线(2)上;从内核发出的数据也经由genl总线送至netlink子系统,再打包送至用户空间。
Generic Netlink控制器(4)作为内核的一部分,负责动态地分配genl通道(即genl family id),并管理genl任务。genl控制器是一个特殊的genl内核用户,它负责监听genl bus上的通信通道。genl通信建立在一系列的通信通道的基础上,每个genl family对应多个通道,这些通道由genl控制器动态分配。

Generic Netlink相关结构体

genl family

Generic Netlink是基于客户端-服务端模型的通信机制。服务端注册family(family是对genl服务的各项定义的集合)。控制器和客户端都通过已注册的信息与服务端通信。
genl family的结构体如下:

struct genl_family
{
      unsigned int            id;
      unsigned int            hdrsize;
      char                    name[GENL_NAMSIZ];
      unsigned int            version;
      unsigned int            maxattr;
      struct nlattr **        attrbuf;
      struct list_head        ops_list;
      struct list_head        family_list;
};
genl 报文格式
genl_ops 结构体
struct genl_ops
{
      u8                      cmd;
      unsigned int            flags;
      struct nla_policy       *policy;
      int                     (*doit)(struct sk_buff *skb,
                                      struct genl_info *info);
      int                     (*dumpit)(struct sk_buff *skb,
                                          struct netlink_callback *cb);
      struct list_head        ops_list;
};

cmd: 命令名。用于识别各genl_ops
flag: 各种设置属性,以“或”连接。在需要admin特权级别时,使用GENL_ADMIN_PERM
policy:定义了attr规则。如果此指针非空,genl在触发事件处理程序之前,会使用这个字段来对帧中的attr做校验(见nlmsg_parse函数)。该字段可以为空,表示在触发事件处理程序之前,不做校验。

doit:这是一个回调函数。在generic netlink收到数据时触发,运行在进程上下文。
doit传入两个参数,skb为触发此回调函数的socket buffer。第二个参数是一个genl_info结构体

struct genl_info
        {
             u32                     snd_seq;
             u32                     snd_pid;
             struct nlmsghdr *       nlhdr;
             struct genlmsghdr *     genlhdr;
             void *                  userhdr;
             struct nlattr **        attrs;
        };

dumpit
这是一个回调函数,当genl_ops的flag标志被添加了NLM_F_DUMP以后,每次收到genl消息即会回触发这个函数。dumpit与doit的区别是:dumpit的第一个参数skb不会携带从客户端发来的数据。相反地,开发者应该在skb中填入需要传给客户端的数据,然后,并skb的数据长度(可以用skb->len)return。skb中携带的数据会被自动送到客户端。只要dumpit的返回值大于0,dumpit函数就会再次被调用,并被要求在skb中填入数据。当服务端没有数据要传给客户端时,dumpit要返回0。如果函数中出错,要求返回一个负值。关于doit和dumpit的触发过程,可以查看源码中的genl_rcv_msg函数。

ops_list
为私有字段,由系统自动配置,开发者不需要做配置。

Generic Netlink 服务端(内核)初始化

初始化Generic Netlink的过程分为以下四步:定义family,定义operation,注册family,注册operation。
Datapath使用 generic netlink

在 dp_init()函数(datapath.c)中,调用 dp_register_genl()完成对四种类型的 family 以 及相应操作的注册,包括 datapath、vport、flow 和 packet。前三种 family,都对应四种操 作都包括 NEW、DEL、GET、SET,而 packet 的操作仅为 EXECUTE。
这些 family 和操作的定义均在 datapath.c 中。 以 flow family 为例。代码为

static const struct nla_policy flow_policy[OVS_FLOW_ATTR_MAX + 1] = { 
    [OVS_FLOW_ATTR_KEY] = { .type = NLA_NESTED }, 
    [OVS_FLOW_ATTR_ACTIONS] = { .type = NLA_NESTED }, 
    [OVS_FLOW_ATTR_CLEAR] = { .type = NLA_FLAG },
};
static struct genl_family dp_flow_genl_family = { 
    .id = GENL_ID_GENERATE,
    .hdrsize = sizeof(struct ovs_header),
    .name = OVS_FLOW_FAMILY,
    .version = OVS_FLOW_VERSION,
    .maxattr = OVS_FLOW_ATTR_MAX, SET_NETNSOK
};

绑定的 ops 的定义

static struct genl_ops dp_flow_genl_ops[] = { 
    { .cmd = OVS_FLOW_CMD_NEW,
      .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */  
      .policy = flow_policy,
      .doit = ovs_flow_cmd_new_or_set
    },
    { .cmd = OVS_FLOW_CMD_DEL,
      .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */ 
      .policy = flow_policy,
      .doit = ovs_flow_cmd_del 
    },
    { .cmd = OVS_FLOW_CMD_GET,
      .flags = 0, /* OK for unprivileged users. */ 
      .policy = flow_policy,
      .doit = ovs_flow_cmd_get,
      .dumpit = ovs_flow_cmd_dump
    },
    { .cmd = OVS_FLOW_CMD_SET,
      .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */ 
      .policy = flow_policy,
      .doit = ovs_flow_cmd_new_or_set,
    }, 
};

ovsd 使用 netlink
ovsd 对于 netlink 的实现,主要在 lib/netlink-socket.c 文件中。而对这些 netlink 操作的 调用,主要在 lib/dpif-linux.c 文件(以 dpif_linux_class 为例)中对于各个行为的处理,各 种可能的消息类型在 datapath 模块中事先进行了内核注册。
datapath 中对 netlink family 类型进行了注册,ovsd 在使用这些 netlink family 之前需要 获取它们的信息,这一过程主要在 lib/dpif-linux.c 文件(以 dpif_linux_class 为例), dpif_linux_init()函数。代码为

static int dpif_linux_init(void) 
{
    static int error = -1;
    if (error < 0) {
        unsigned int ovs_vport_mcgroup;
        error = nl_lookup_genl_family(OVS_DATAPATH_FAMILY,&ovs_datapath_family);
        if (error) {
            VLOG_ERR("Generic Netlink family '%s' does not exist. ""The Open vSwitch kernel module is probably not loaded.",OVS_DATAPATH_FAMILY); }
        if (!error) {
            error = nl_lookup_genl_family(OVS_VPORT_FAMILY, &ovs_vport_family);}
        if (!error) {
            error = nl_lookup_genl_family(OVS_FLOW_FAMILY, &ovs_flow_family); }
        if (!error) {
            error = nl_lookup_genl_family(OVS_PACKET_FAMILY,&ovs_packet_family);}
        if (!error) {
            error = nl_sock_create(NETLINK_GENERIC, &genl_sock); }
        if (!error) {
            error = nl_lookup_genl_mcgroup(OVS_VPORT_FAMILY, OVS_VPORT_MCGROUP,&ovs_vport_mcgroup, OVS_VPORT_MCGROUP_FALLBACK_ID);}
        if (!error) {
            static struct dpif_linux_vport vport;
            nln = nln_create(NETLINK_GENERIC, ovs_vport_mcgroup,
            dpif_linux_nln_parse, &vport);}
     }
    return error; 
}

完成这些查找后,ovsd 即可利用 dpif 中的 api,通过发出这些 netlink 消息给 datapath 实现对 datapath 的操作。

相关的中间层 API 定义主要在 dpif_class(位于 lib/dpif-provider.h)的抽象类型中
dpif_class结构体的注释:

/* Datapath interface class structure, to be defined by each implementation of
-a datapath interface.
 *
- These functions return 0 if successful or a positive errno value on failure,
- except where otherwise noted.
 *
- These functions are expected to execute synchronously, that is, to block as
- necessary to obtain a result.  Thus, they may not return EAGAIN or
- EWOULDBLOCK or EINPROGRESS.  We may relax this requirement in the future if
- and when we encounter performance problems. */

一共有两种dpif_class实例化类型,分别为dpif_netlink_class和dpif_netdev_class。dpif_netlink_class表示的是通过netlink和本地的datapath通信,而dpif_netdev_class通过网络协议和远程的datapath通信
ovsd使用netlink进行消息发送的过程:


参考内容


庾志辉OVS 专栏
http://blog.csdn.net/column/details/openvswitch.html
datapath 模块分析
http://vinllen.com/ovs-datapathbi-ji/
Baohua Yang的OpenvSwitch 代码分析
OpenvSwitch2.4.0源码解读
http://www.cnblogs.com/cotyb/p/5103035.html?utm_source=tuicool&utm_medium=referral
GenerRic Netlink 详解
http://www.tuicool.com/articles/jE7nim

上一篇下一篇

猜你喜欢

热点阅读