Openvswitch原理与代码分析(4):网络包的处理过程

时间:2019-08-23
本文章向大家介绍Openvswitch原理与代码分析(4):网络包的处理过程,主要包括Openvswitch原理与代码分析(4):网络包的处理过程使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。

 

 

在上一节提到,Openvswitch的内核模块openvswitch.ko会在网卡上注册一个函数netdev_frame_hook,每当有网络包到达网卡的时候,这个函数就会被调用。

 

  1. static struct sk_buff *netdev_frame_hook(struct sk_buff *skb)
  2. {
  3.    if (unlikely(skb->pkt_type == PACKET_LOOPBACK))
  4.       return skb;
  5.  
  6.    port_receive(skb);
  7.    return NULL;
  8. }

 

调用port_receive即是调用netdev_port_receive

#define port_receive(skb) netdev_port_receive(skb, NULL)

 

  1. void netdev_port_receive(struct sk_buff *skb, struct ip_tunnel_info *tun_info)
  2. {
  3.    struct vport *vport;
  4.  
  5.    vport = ovs_netdev_get_vport(skb->dev);
  6. ……
  7.    skb_push(skb, ETH_HLEN);
  8.    ovs_skb_postpush_rcsum(skb, skb->data, ETH_HLEN);
  9.    ovs_vport_receive(vport, skb, tun_info);
  10.    return;
  11. error:
  12.    kfree_skb(skb);
  13. }

 

在函数int ovs_vport_receive(struct vport *vport, struct sk_buff *skb, const struct ip_tunnel_info *tun_info)实现如下

  1. int ovs_vport_receive(struct vport *vport, struct sk_buff *skb,
  2.             const struct ip_tunnel_info *tun_info)
  3. {
  4.    struct sw_flow_key key;
  5.    ......
  6.    /* Extract flow from 'skb' into 'key'. */
  7.    error = ovs_flow_key_extract(tun_info, skb, &key);
  8.    if (unlikely(error)) {
  9.       kfree_skb(skb);
  10.       return error;
  11.    }
  12.    ovs_dp_process_packet(skb, &key);
  13.    return 0;
  14. }

 

在这个函数里面,首先声明了变量struct sw_flow_key key;

如果我们看这个key的定义

  1. struct sw_flow_key {
  2.    u8 tun_opts[255];
  3.    u8 tun_opts_len;
  4.    struct ip_tunnel_key tun_key; /* Encapsulating tunnel key. */
  5.    struct {
  6.       u32 priority; /* Packet QoS priority. */
  7.       u32 skb_mark; /* SKB mark. */
  8.       u16 in_port; /* Input switch port (or DP_MAX_PORTS). */
  9.    } __packed phy; /* Safe when right after 'tun_key'. */
  10.    u32 ovs_flow_hash; /* Datapath computed hash value. */
  11.    u32 recirc_id; /* Recirculation ID. */
  12.    struct {
  13.       u8 src[ETH_ALEN]; /* Ethernet source address. */
  14.       u8 dst[ETH_ALEN]; /* Ethernet destination address. */
  15.       __be16 tci; /* 0 if no VLAN, VLAN_TAG_PRESENT set otherwise. */
  16.       __be16 type; /* Ethernet frame type. */
  17.    } eth;
  18.    union {
  19.       struct {
  20.          __be32 top_lse; /* top label stack entry */
  21.       } mpls;
  22.       struct {
  23.          u8 proto; /* IP protocol or lower 8 bits of ARP opcode. */
  24.          u8 tos; /* IP ToS. */
  25.          u8 ttl; /* IP TTL/hop limit. */
  26.          u8 frag; /* One of OVS_FRAG_TYPE_*. */
  27.       } ip;
  28.    };
  29.    struct {
  30.       __be16 src; /* TCP/UDP/SCTP source port. */
  31.       __be16 dst; /* TCP/UDP/SCTP destination port. */
  32.       __be16 flags; /* TCP flags. */
  33.    } tp;
  34.    union {
  35.       struct {
  36.          struct {
  37.             __be32 src; /* IP source address. */
  38.             __be32 dst; /* IP destination address. */
  39.          } addr;
  40.          struct {
  41.             u8 sha[ETH_ALEN]; /* ARP source hardware address. */
  42.             u8 tha[ETH_ALEN]; /* ARP target hardware address. */
  43.          } arp;
  44.       } ipv4;
  45.       struct {
  46.          struct {
  47.             struct in6_addr src; /* IPv6 source address. */
  48.             struct in6_addr dst; /* IPv6 destination address. */
  49.          } addr;
  50.          __be32 label; /* IPv6 flow label. */
  51.          struct {
  52.             struct in6_addr target; /* ND target address. */
  53.             u8 sll[ETH_ALEN]; /* ND source link layer address. */
  54.             u8 tll[ETH_ALEN]; /* ND target link layer address. */
  55.          } nd;
  56.       } ipv6;
  57.    };
  58.    struct {
  59.       /* Connection tracking fields. */
  60.       u16 zone;
  61.       u32 mark;
  62.       u8 state;
  63.       struct ovs_key_ct_labels labels;
  64.    } ct;
  65.  
  66. } __aligned(BITS_PER_LONG/8); /* Ensure that we can do comparisons as longs. */

 

可见这个key里面是一个大杂烩,数据包里面的几乎任何部分都可以作为key来查找flow表

  • tunnel可以作为key
  • 在物理层,in_port即包进入的网口的ID
  • 在MAC层,源和目的MAC地址
  • 在IP层,源和目的IP地址
  • 在传输层,源和目的端口号
  • IPV6

所以,要在内核态匹配流表,首先需要调用ovs_flow_key_extract,从包的正文中提取key的值。

接下来就是要调用ovs_dp_process_packet了。

  1. void ovs_dp_process_packet(struct sk_buff *skb, struct sw_flow_key *key)
  2. {
  3.    const struct vport *p = OVS_CB(skb)->input_vport;
  4.    struct datapath *dp = p->dp;
  5.    struct sw_flow *flow;
  6.    struct sw_flow_actions *sf_acts;
  7.    struct dp_stats_percpu *stats;
  8.    u64 *stats_counter;
  9.    u32 n_mask_hit;
  10.  
  11.    stats = this_cpu_ptr(dp->stats_percpu);
  12.  
  13.    /* Look up flow. */
  14.    flow = ovs_flow_tbl_lookup_stats(&dp->table, key, skb_get_hash(skb),
  15.                 &n_mask_hit);
  16.    if (unlikely(!flow)) {
  17.       struct dp_upcall_info upcall;
  18.       int error;
  19.  
  20.       memset(&upcall, 0, sizeof(upcall));
  21.       upcall.cmd = OVS_PACKET_CMD_MISS;
  22.       upcall.portid = ovs_vport_find_upcall_portid(p, skb);
  23.       upcall.mru = OVS_CB(skb)->mru;
  24.       error = ovs_dp_upcall(dp, skb, key, &upcall);
  25.       if (unlikely(error))
  26.          kfree_skb(skb);
  27.       else
  28.          consume_skb(skb);
  29.       stats_counter = &stats->n_missed;
  30.       goto out;
  31.    }
  32.  
  33.    ovs_flow_stats_update(flow, key->tp.flags, skb);
  34.    sf_acts = rcu_dereference(flow->sf_acts);
  35.    ovs_execute_actions(dp, skb, sf_acts, key);
  36.  
  37.    stats_counter = &stats->n_hit;
  38.  
  39. out:
  40.    /* Update datapath statistics. */
  41.    u64_stats_update_begin(&stats->syncp);
  42.    (*stats_counter)++;
  43.    stats->n_mask_hit += n_mask_hit;
  44.    u64_stats_update_end(&stats->syncp);
  45. }

 

这个函数首先在内核里面的流表中查找符合key的flow,也即ovs_flow_tbl_lookup_stats,如果找到了,很好说明用户态的流表已经放入内核,则走fast path就可了。于是直接调用ovs_execute_actions,执行这个key对应的action。

如果不能找到,则只好调用ovs_dp_upcall,让用户态去查找流表。会调用static int queue_userspace_packet(struct datapath *dp, struct sk_buff *skb, const struct sw_flow_key *key, const struct dp_upcall_info *upcall_info)

它会调用err = genlmsg_unicast(ovs_dp_get_net(dp), user_skb, upcall_info->portid);通过netlink将消息发送给用户态。在用户态,有线程监听消息,一旦有消息,则触发udpif_upcall_handler。

 

Slow Path & Fast Path

Slow Path:

当Datapath找不到flow rule对packet进行处理时

Vswitchd使用flow rule对packet进行处理。

 

Fast Path:

将slow path的flow rule放在内核态,对packet进行处理

 

Unknown Packet Processing

Datapath使用flow rule对packet进行处理,如果没有,则有vswitchd使用flow rule进行处理

 

 

  1. 从Device接收Packet交给事先注册的event handler进行处理
  2. 接收Packet后识别是否是unknown packet,是则交由upcall处理
  3. vswitchd对unknown packet找到flow rule进行处理
  4. 将Flow rule发送给datapath

 

$flag 上一页 下一页

上一篇:注解 @CrossOrigin

下一篇:E. Boxers