ovs，全名openvswitch，是一个高质量的、多层虚拟交换机，相对于bridge的一些优势：
1）方便网络管理与监控。OVS 的引入，可以方便管理员对整套云环境中的网络状态和数据流量进行监控，比如可以分析网络中流淌的数据包是来自哪个 VM、哪个 OS 及哪个用户，这些都可以借助 OVS 提供的工具来达到。
2）加速数据包的寻路与转发。相比 Bridge 单纯的基于 MAC 地址学习的转发规则，OVS 引入流缓存的机制，可以加快数据包的转发效率。
3）基于 SDN 控制面与数据面分离的思想。上面两点其实都跟这一点有关，OVS 控制面负责流表的学习与下发，具体的转发动作则有数据面来完成。可扩展性强。
4）隧道协议支持。Bridge 只支持 VxLAN，OVS 支持 gre/vxlan/IPsec 等。
5）适用于 Xen、KVM、VirtualBox、VMware 等多种 Hypervisors。
不过这些年，openflow明显热度降低，SDN网络可以有很多实现方式，如segment routing技术，结合传统的mpls/bgp，也能很好的实现SDN，相比于基于openflow协议的SDN网络，设备厂商支持的更好，更稳定。
同bridge一样，在向ovs bridge中添加成员接口的时候，会在成员接口的dev->rx_handler 上挂载收包处理函数，如下，ovs_vport_add 中会根据加入接口类型的不同，调用接口对应的create函数，而所有create函数都会调用ovs_netdev_link，其中注册了netdev_frame_hook 作为ovs成员口的收包处理函数。
以vxlan_create为例，vxlan本身的创建和linux vxlan一样，核心函数也是vxlan_dev_configure，其次是创建ovs成员口的私有数据 vport，最后在ovs_netdev_link 函数中间vxlan和vport关联，以及挂载接口收报函数和私有数据（netdev_frame_hook，vport）
struct vport *ovs_vport_add(const struct vport_parms *parms)
{
struct vport_ops *ops;
struct vport *vport;
ops = ovs_vport_lookup(parms);
if (ops) {
struct hlist_head *bucket;
if (!try_module_get(ops->owner))
return ERR_PTR(-EAFNOSUPPORT);
vport = ops->create(parms);
......
}
struct vport *ovs_netdev_link(struct vport *vport, const char *name)
{
......
err = netdev_rx_handler_register(vport->dev, netdev_frame_hook,
vport);
......
}
EXPORT_SYMBOL_GPL(ovs_netdev_link);
image.png
网卡收到包后，走到__netif_receive_skb_core后，剥完vlan找到vlan子接口（如果有的话），如果skb->dev是ovs成员口，就会走到netdev_frame_hook处理函数。
static int __netif_receive_skb_core(struct sk_buff *skb, bool pfmemalloc)
{
......
// ovs挂载的 netdev_frame_hook 函数。
rx_handler = rcu_dereference(skb->dev->rx_handler);
if (rx_handler) {
if (pt_prev) {
ret = deliver_skb(skb, pt_prev, orig_dev);
pt_prev = NULL;
}
switch (rx_handler(&skb)) {
case RX_HANDLER_CONSUMED: // 报文已经被消费，结束处理
ret = NET_RX_SUCCESS;
goto out;
case RX_HANDLER_ANOTHER: // skb->dev 被修改，重新走一次
goto another_round;
case RX_HANDLER_EXACT: /* 精确传递到ptype->dev == skb->dev */
deliver_exact = true;
case RX_HANDLER_PASS:
break;
default:
BUG();
}
}
......
}
struct vport 是ovs成员端口的核心数据结构，它挂载在net_device 的rx_handler_data 上成员上，ovs模块中用的更多的是这个结构，但对外部模块不可见（私有数据结构）。
struct vport {
struct net_device *dev;
struct datapath *dp; // 对应一个bridge，ovs中可以添加多个bridge。
struct vport_portids __rcu *upcall_portids;
u16 port_no;
struct hlist_node hash_node;
struct hlist_node dp_hash_node;
const struct vport_ops *ops; // 对应不同接口类型的操作处理函数。
struct list_head detach_list;
struct rcu_head rcu;
};
netdev_frame_hook --> netdev_port_receive -->ovs_vport_receive-->ovs_dp_process_packet 流程。在进入 ovs_dp_process_packet 之前，从tun_info和 skb,提取了流的key信息，包含 tunnel、二层、三层、四层的报文头信息，为ovs dp匹配流表提供依据。
static void netdev_port_receive(struct sk_buff *skb)
{
struct vport *vport;
vport = ovs_netdev_get_vport(skb->dev);
if (unlikely(!vport))
goto error;
if (unlikely(skb_warn_if_lro(skb)))
goto error;
skb = skb_share_check(skb, GFP_ATOMIC);
if (unlikely(!skb))
return;
// ovs 是 switch，所以智能加二层口，向一些三层的tunnel口是无法加入的
skb_push(skb, ETH_HLEN);
skb_postpush_rcsum(skb, skb->data, ETH_HLEN);
// 一些tunnel口，如vxlan、gre，会在skb的dst_entry中缓存tunnel key
ovs_vport_receive(vport, skb, skb_tunnel_info(skb));
return;
error:
kfree_skb(skb);
}
int ovs_vport_receive(struct vport *vport, struct sk_buff *skb,
const struct ip_tunnel_info *tun_info)
{
struct sw_flow_key key;
int error;
OVS_CB(skb)->input_vport = vport;
OVS_CB(skb)->mru = 0;
OVS_CB(skb)->cutlen = 0;
if (unlikely(dev_net(skb->dev) != ovs_dp_get_net(vport->dp))) {
u32 mark;
mark = skb->mark;
skb_scrub_packet(skb, true);
skb->mark = mark;
tun_info = NULL;
}
/* Extract flow from 'skb' into 'key'. */
// 这里从tun_info和 skb,提取了流的key信息，sw_flow_key 包含 tunnel、二层、三层、四层的报文头信息，为ovs dp匹配流表提供依据。
error = ovs_flow_key_extract(tun_info, skb, &key);
if (unlikely(error)) {
kfree_skb(skb);
return error;
}
ovs_dp_process_packet(skb, &key);
return 0;
}
ovs_dp_process_packet 函数会根据报文key match流表：
1、如果没找到，走upcall处理，调用 queue_userspace_packet 将报文各层协议头 （OVS_PACKET_ATTR_KEY ）、skb本身数据（OVS_PACKET_ATTR_PACKET）信息上送用户态（upcall.cmd=OVS_PACKET_CMD_MISS），用户态会有线程监听消息，在udpif_start_threads中创建了处理upcall的线程，处理handler = udpif_upcall_handler，udpif_upcall_handler通过fd poll的方式等待触发，如果有upcall上送，则进入recv_upcalls的处理函数中
1)从Device接收Packet交给事先注册的event handler进行处理;
2)接收Packet后识别是否是unknown packet，是则交由upcall处理;
3)vswitchd对unknown packet找到flow rule进行处理，其中最重要的调用是通过rule_dpif_lookup_from_table查找到匹配的流表规则，进而生成actions
rule_dpif_lookup_from_table又会通过流表的级联一个个顺序查找，每单个流表都会调用rule_dpif_lookup_in_table;
4)经过process_upcall流程后，已经为upcall的流生成对应的缓存流表信息了，缓存流表的key信息以及actions动作保存在struct upcall里，接下去就是要将缓存流表put到datapath了，通知内核态ovs处理put（对应OVS_FLOW_CMD_NEW）及execute（OVS_PACKET_CMD_EXECUTE）流程；
https://www.codenong.com/cs109398201/
2、存在匹配的流表，根据流表的action，执行相应的操作。action 类型很多，但最终一般需要是output action，从一个接口发送出去。
void ovs_dp_process_packet(struct sk_buff *skb, struct sw_flow_key *key)
{
const struct vport *p = OVS_CB(skb)->input_vport;
struct datapath *dp = p->dp;
struct sw_flow *flow;
struct sw_flow_actions *sf_acts;
struct dp_stats_percpu *stats;
u64 *stats_counter;
u32 n_mask_hit;
stats = this_cpu_ptr(dp->stats_percpu);
/* Look up flow. */
// 流表查询，根据前面从报文提取的信息
flow = ovs_flow_tbl_lookup_stats(&dp->table, key, &n_mask_hit);
if (unlikely(!flow)) {
struct dp_upcall_info upcall;
int error;
// 未查找到流表，做upcall 处理
memset(&upcall, 0, sizeof(upcall));
upcall.cmd = OVS_PACKET_CMD_MISS;
upcall.portid = ovs_vport_find_upcall_portid(p, skb);
upcall.mru = OVS_CB(skb)->mru;
error = ovs_dp_upcall(dp, skb, key, &upcall, 0);
if (unlikely(error))
kfree_skb(skb);
else
consume_skb(skb);
stats_counter = &stats->n_missed;
goto out;
}
// 查找到了流表，根据流表的action，执行相应的操作。
ovs_flow_stats_update(flow, key->tp.flags, skb);
sf_acts = rcu_dereference(flow->sf_acts);
ovs_execute_actions(dp, skb, sf_acts, key);
stats_counter = &stats->n_hit;
out:
/* Update datapath statistics. */
u64_stats_update_begin(&stats->syncp);
(*stats_counter)++;
stats->n_mask_hit += n_mask_hit;
u64_stats_update_end(&stats->syncp);
}
int ovs_execute_actions(struct datapath *dp, struct sk_buff *skb,
const struct sw_flow_actions *acts,
struct sw_flow_key *key)
{
int err, level;
level = __this_cpu_inc_return(exec_actions_level);
if (unlikely(level > OVS_RECURSION_LIMIT)) {
net_crit_ratelimited("ovs: recursion limit reached on datapath %s, probable configuration error\n",
ovs_dp_name(dp));
kfree_skb(skb);
err = -ENETDOWN;
goto out;
}
OVS_CB(skb)->acts_origlen = acts->orig_len;
err = do_execute_actions(dp, skb, key,
acts->actions, acts->actions_len);
if (level == 1)
process_deferred_actions(dp);
out:
__this_cpu_dec(exec_actions_level);
return err;
}
// action 类型很多，但最终一般需要是output action，从一个接口发送出去
static int do_execute_actions(struct datapath *dp, struct sk_buff *skb,
struct sw_flow_key *key,
const struct nlattr *attr, int len)
{
/* Every output action needs a separate clone of 'skb', but the common
* case is just a single output action, so that doing a clone and
* then freeing the original skbuff is wasteful. So the following code
* is slightly obscure just to avoid that.
*/
int prev_port = -1;
const struct nlattr *a;
int rem;
for (a = attr, rem = len; rem > 0;
a = nla_next(a, &rem)) {
int err = 0;
if (unlikely(prev_port != -1)) {
struct sk_buff *out_skb = skb_clone(skb, GFP_ATOMIC);
if (out_skb)
do_output(dp, out_skb, prev_port, key);
OVS_CB(skb)->cutlen = 0;
prev_port = -1;
}
switch (nla_type(a)) {
case OVS_ACTION_ATTR_OUTPUT:
prev_port = nla_get_u32(a);
break;
case OVS_ACTION_ATTR_TRUNC: {
struct ovs_action_trunc *trunc = nla_data(a);
if (skb->len > trunc->max_len)
OVS_CB(skb)->cutlen = skb->len - trunc->max_len;
break;
}
case OVS_ACTION_ATTR_USERSPACE:
output_userspace(dp, skb, key, a, attr,
len, OVS_CB(skb)->cutlen);
OVS_CB(skb)->cutlen = 0;
break;
case OVS_ACTION_ATTR_HASH:
execute_hash(skb, key, a);
break;
case OVS_ACTION_ATTR_PUSH_MPLS:
err = push_mpls(skb, key, nla_data(a));
break;
case OVS_ACTION_ATTR_POP_MPLS:
err = pop_mpls(skb, key, nla_get_be16(a));
break;
case OVS_ACTION_ATTR_PUSH_VLAN:
err = push_vlan(skb, key, nla_data(a));
break;
case OVS_ACTION_ATTR_POP_VLAN:
err = pop_vlan(skb, key);
break;
case OVS_ACTION_ATTR_RECIRC:
err = execute_recirc(dp, skb, key, a, rem);
if (nla_is_last(a, rem)) {
/* If this is the last action, the skb has
* been consumed or freed.
* Return immediately.
*/
return err;
}
break;
case OVS_ACTION_ATTR_SET:
err = execute_set_action(skb, key, nla_data(a));
break;
case OVS_ACTION_ATTR_SET_MASKED:
case OVS_ACTION_ATTR_SET_TO_MASKED:
err = execute_masked_set_action(skb, key, nla_data(a));
break;
case OVS_ACTION_ATTR_SAMPLE:
err = sample(dp, skb, key, a, attr, len);
break;
case OVS_ACTION_ATTR_CT:
if (!is_flow_key_valid(key)) {
err = ovs_flow_key_update(skb, key);
if (err)
return err;
}
err = ovs_ct_execute(ovs_dp_get_net(dp), skb, key,
nla_data(a));
/* Hide stolen IP fragments from user space. */
if (err)
return err == -EINPROGRESS ? 0 : err;
break;
}
if (unlikely(err)) {
kfree_skb(skb);
return err;
}
}
if (prev_port != -1)
do_output(dp, skb, prev_port, key);
else
consume_skb(skb);
return 0;
}
接口的output操作，流程是 do_output -->ovs_vport_send --> vport 注册的send函数，都是直接调用的 dev_queue_xmit 函数，因为ovs进来的是二层包，流表只是对报头做了修改，再转发出去，不需要走协议栈。
网友评论