OVS 源码分析

OVS 核心代码

• datapath 目录
• ovs-switchd
• OVS数据库管理
• ofproto

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()
• ovs_dp_process_received_packet()

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函数依次调用函数

• 必选调用dpif_run()处理所有注册的netlink notifier的汇报事件
• 必选调用run_fast()处理常见的周期事件，包括对upcalls的处理等
• 可选调用netflow_run()和sflow_run()，进行对netflow和sflow的支持

可选调用较多，自行查看

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

• 首先检查是否存在in_band的控制器
• 调用ofconn_run()处理对ofproto的协议解析和行动
• rconn_run(ofconn->rconn)负责连接到controller
• rconn_recv(ofconn->rconn)负责从controller收取消息
• handle_openflow()最终调用handle_openflow__()（ofproto/ofproto.c）来完成对各个Of消息的处理

以 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 testBR2. 内核中的 openvswitch.ko 收到一个添加网桥的命令时候——即收到 OVS_DATAPATH_FAMILY通道的 OVS_DP_CMD_NEW命令。该命令绑定的回调函数为 ovs_dp_cmd_new3. ovs_dp_cmd_new 函数除了初始化 dp 结构外，调用 new_vport 函数来生成新的 vport4. new_vport 函数调用 ovs_vport_add()来尝试生成一个新的 vport5. 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 消息到 skb8. 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;};

• id: family id。当新注册一个family的时候，应该用GENL_ID_GENERATE宏(0x0)，表示请控制器自动为family分配的一个id。0x10保留供genl控制器使用。
• hdrsize: 用户自定议头部长度。即图2中User Msg的长度。如果没有用户自定义头部，这个值被赋为0。
• version: 版本号，一般填1即可。
• name: family名，要求不同的family使用不同的名字。以便控制器进行正确的查找。
• maxattr：genl使用netlink标准的attr来传输数据。此字段定义了最大attr类型数。（注意：不是一次传输多少个attr，而是一共有多少种attr，因此，这个值可以被设为0，为0代表不区分所收到的数据的attr type）。在接收数据时，可以根据attr type，获得指定的attr type的数据在整体数据中的位置。
• 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;        };

• snd_seq：发送序号
• snd_pid：发送客户端的PID
• nlhdr：netlink header的指针
• genlmsghdr：genl头部的指针（即family头部）
• userhdr：用户自定义头部指针
• attrs：attrs，如果定义了genl_ops->policy，这里的attrs是被policy过滤以后的结果。在完成了操作以后，如果执行正确，返回0；否则，返回一个负数。负数的返回值会触发NLMSG_ERROR消息。当genl_ops的flag标志被添加了NLMSG_ERROR时，即使doit返回0，也会触发NLMSG_ERROR消息。

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进行消息发送的过程：