openvswitch datapath 内核态流表创建过程（ovs_flow_cmd_new）

datapath流表更新的入口函数都定义在dp_flow_genl_ops中，流表创建的入口函数是ovs_flow_cmd_new函数，通过该函数，我们可以一窥流表相关信息的建立。

1、ovs_flow_cmd_new函数

 static int ovs_flow_cmd_new(struct sk_buff *skb, struct genl_info *info)
 {
     struct net *net = sock_net(skb->sk);
     struct nlattr **a = info->attrs;
     struct ovs_header *ovs_header = info->userhdr;
     struct sw_flow *flow = NULL, *new_flow;
     struct sw_flow_mask mask;
     struct sk_buff *reply;
     struct datapath *dp;
     struct sw_flow_actions *acts;
     struct sw_flow_match match;
     u32 ufid_flags = ovs_nla_get_ufid_flags(a[OVS_FLOW_ATTR_UFID_FLAGS]);
     int error;
     bool log = !a[OVS_FLOW_ATTR_PROBE];

     /* Must have key and actions. */
     error = -EINVAL;
     if (!a[OVS_FLOW_ATTR_KEY]) {
         OVS_NLERR(log, "Flow key attr not present in new flow.");
         goto error;
     }
     if (!a[OVS_FLOW_ATTR_ACTIONS]) {
         OVS_NLERR(log, "Flow actions attr not present in new flow.");
         goto error;
     }

     /* Most of the time we need to allocate a new flow, do it before
      * locking.
      */
     new_flow = ovs_flow_alloc();
     if (IS_ERR(new_flow)) {
         error = PTR_ERR(new_flow);
         goto error;
     }

     /* Extract key. */
     ovs_match_init(&match, &new_flow->key, false, &mask);
     error = ovs_nla_get_match(net, &match, a[OVS_FLOW_ATTR_KEY],
                   a[OVS_FLOW_ATTR_MASK], log);
     if (error)
         goto err_kfree_flow;

     /* Extract flow identifier. */
     error = ovs_nla_get_identifier(&new_flow->id, a[OVS_FLOW_ATTR_UFID],
                        &new_flow->key, log);
     if (error)
         goto err_kfree_flow;

     /* unmasked key is needed to match when ufid is not used. */
     if (ovs_identifier_is_key(&new_flow->id))
         match.key = new_flow->id.unmasked_key;

     ovs_flow_mask_key(&new_flow->key, &new_flow->key, true, &mask);

     /* Validate actions. */
     error = ovs_nla_copy_actions(net, a[OVS_FLOW_ATTR_ACTIONS],
                      &new_flow->key, &acts, log);
     if (error) {
         OVS_NLERR(log, "Flow actions may not be safe on all matching packets.");
         goto err_kfree_flow;
     }

     reply = ovs_flow_cmd_alloc_info(acts, &new_flow->id, info, false,
                     ufid_flags);
     if (IS_ERR(reply)) {
         error = PTR_ERR(reply);
         goto err_kfree_acts;
     }

     ovs_lock();
     dp = get_dp(net, ovs_header->dp_ifindex);
     if (unlikely(!dp)) {
         error = -ENODEV;
         goto err_unlock_ovs;
     }

     /* Check if this is a duplicate flow */
     if (ovs_identifier_is_ufid(&new_flow->id))
         flow = ovs_flow_tbl_lookup_ufid(&dp->table, &new_flow->id);
     if (!flow)
         flow = ovs_flow_tbl_lookup(&dp->table, &new_flow->key);
     if (likely(!flow)) {
         rcu_assign_pointer(new_flow->sf_acts, acts);

         /* Put flow in bucket. */
         error = ovs_flow_tbl_insert(&dp->table, new_flow, &mask);
         if (unlikely(error)) {
             acts = NULL;
             goto err_unlock_ovs;
         }

         if (unlikely(reply)) {
             error = ovs_flow_cmd_fill_info(new_flow,
                                ovs_header->dp_ifindex,
                                reply, info->snd_portid,
                                info->snd_seq, 0,
                                OVS_FLOW_CMD_NEW,
                                ufid_flags);
             BUG_ON(error < 0);
         }
         ovs_unlock();
     } else {
         struct sw_flow_actions *old_acts;

         /* Bail out if we're not allowed to modify an existing flow.
          * We accept NLM_F_CREATE in place of the intended NLM_F_EXCL
          * because Generic Netlink treats the latter as a dump
          * request.  We also accept NLM_F_EXCL in case that bug ever
          * gets fixed.
          */
         if (unlikely(info->nlhdr->nlmsg_flags & (NLM_F_CREATE
                              | NLM_F_EXCL))) {
             error = -EEXIST;
             goto err_unlock_ovs;
         }
         /* The flow identifier has to be the same for flow updates.
          * Look for any overlapping flow.
          */
         if (unlikely(!ovs_flow_cmp(flow, &match))) {
             if (ovs_identifier_is_key(&flow->id))
                 flow = ovs_flow_tbl_lookup_exact(&dp->table,
                                  &match);
             else /* UFID matches but key is different */
                 flow = NULL;
             if (!flow) {
                 error = -ENOENT;
                 goto err_unlock_ovs;
             }
         }
         /* Update actions. */
         old_acts = ovsl_dereference(flow->sf_acts);
         rcu_assign_pointer(flow->sf_acts, acts);

         if (unlikely(reply)) {
             error = ovs_flow_cmd_fill_info(flow,
                                ovs_header->dp_ifindex,
                                reply, info->snd_portid,
                                info->snd_seq, 0,
                                OVS_FLOW_CMD_NEW,
                                ufid_flags);
             BUG_ON(error < 0);
         }
         ovs_unlock();

         ovs_nla_free_flow_actions_rcu(old_acts);
         ovs_flow_free(new_flow, false);
     }

     if (reply)
         ovs_notify(&dp_flow_genl_family, &ovs_dp_flow_multicast_group, reply, info);
     return 0;

 err_unlock_ovs:
     ovs_unlock();
     kfree_skb(reply);
 err_kfree_acts:
     ovs_nla_free_flow_actions(acts);
 err_kfree_flow:
     ovs_flow_free(new_flow, false);
 error:
     return error;
 }

2、ovs_flow_tbl_insert函数

 /* Must be called with OVS mutex held. */
 int ovs_flow_tbl_insert(struct flow_table *table, struct sw_flow *flow,
             const struct sw_flow_mask *mask)
 {
     int err;

     err = flow_mask_insert(table, flow, mask);
     if (err)
         return err;
     flow_key_insert(table, flow);
     if (ovs_identifier_is_ufid(&flow->id))
         flow_ufid_insert(table, flow);

     return 0;
 }

3、flow_mask_insert函数

 /* Add 'mask' into the mask list, if it is not already there. */
 static int flow_mask_insert(struct flow_table *tbl, struct sw_flow *flow,
                 const struct sw_flow_mask *new)
 {
     struct sw_flow_mask *mask;

     mask = flow_mask_find(tbl, new);
     if (!mask) {
         struct mask_array *ma;
         int i;

         /* Allocate a new mask if none exsits. */
         mask = mask_alloc();
         if (!mask)
             return -ENOMEM;

         mask->key = new->key;
         mask->range = new->range;

         /* Add mask to mask-list. */
         ma = ovsl_dereference(tbl->mask_array);
         if (ma->count >= ma->max) {
             int err;

             err = tbl_mask_array_realloc(tbl, ma->max +
                               MASK_ARRAY_SIZE_MIN);
             if (err) {
                 kfree(mask);
                 return err;
             }
             ma = ovsl_dereference(tbl->mask_array);
         }

         for (i = 0; i < ma->max; i++) {
             struct sw_flow_mask *t;

             t = ovsl_dereference(ma->masks[i]);
             if (!t) {
                 rcu_assign_pointer(ma->masks[i], mask);
                 ma->count++;
                 break;
             }
         }

     } else {
         BUG_ON(!mask->ref_count);
         mask->ref_count++;
     }

     flow->mask = mask;
     return 0;
 }

4、flow_key_insert函数

 /* Must be called with OVS mutex held. */
 static void flow_key_insert(struct flow_table *table, struct sw_flow *flow)
 {
     struct table_instance *new_ti = NULL;
     struct table_instance *ti;

     flow->flow_table.hash = flow_hash(&flow->key, &flow->mask->range);
     ti = ovsl_dereference(table->ti);
     table_instance_insert(ti, flow);
     table->count++;

     /* Expand table, if necessary, to make room. */
     if (table->count > ti->n_buckets)
         new_ti = table_instance_expand(ti, false);
     else if (time_after(jiffies, table->last_rehash + REHASH_INTERVAL))
         new_ti = table_instance_rehash(ti, ti->n_buckets, false);

     if (new_ti) {
         rcu_assign_pointer(table->ti, new_ti);
         call_rcu(&ti->rcu, flow_tbl_destroy_rcu_cb);
         table->last_rehash = jiffies;
     }
 }

5、table_instance_insert函数

 static void table_instance_insert(struct table_instance *ti,
                   struct sw_flow *flow)
 {
     struct hlist_head *head;

     head = find_bucket(ti, flow->flow_table.hash);
     hlist_add_head_rcu(&flow->flow_table.node[ti->node_ver], head);
 }

6、ovs_nla_copy_actions函数

 /* 'key' must be the masked key. */
 int ovs_nla_copy_actions(struct net *net, const struct nlattr *attr,
              const struct sw_flow_key *key,
              struct sw_flow_actions **sfa, bool log)
 {
     int err;

     *sfa = nla_alloc_flow_actions(min(nla_len(attr), MAX_ACTIONS_BUFSIZE));
     if (IS_ERR(*sfa))
         return PTR_ERR(*sfa);

     (*sfa)->orig_len = nla_len(attr);
     err = __ovs_nla_copy_actions(net, attr, key, sfa, key->eth.type,
                      key->eth.vlan.tci, log);
     if (err)
         ovs_nla_free_flow_actions(*sfa);

     return err;
 }

7、__ovs_nla_copy_actions函数

 static int __ovs_nla_copy_actions(struct net *net, const struct nlattr *attr,
                   const struct sw_flow_key *key,
                   struct sw_flow_actions **sfa,
                   __be16 eth_type, __be16 vlan_tci, bool log)
 {
     u8 mac_proto = ovs_key_mac_proto(key);
     const struct nlattr *a;
     int rem, err;

     nla_for_each_nested(a, attr, rem) {
         /* Expected argument lengths, (u32)-1 for variable length. */
         static const u32 action_lens[OVS_ACTION_ATTR_MAX + 1] = {
             [OVS_ACTION_ATTR_OUTPUT] = sizeof(u32),
             [OVS_ACTION_ATTR_RECIRC] = sizeof(u32),
             [OVS_ACTION_ATTR_USERSPACE] = (u32)-1,
             [OVS_ACTION_ATTR_PUSH_MPLS] = sizeof(struct ovs_action_push_mpls),
             [OVS_ACTION_ATTR_POP_MPLS] = sizeof(__be16),
             [OVS_ACTION_ATTR_PUSH_VLAN] = sizeof(struct ovs_action_push_vlan),
             [OVS_ACTION_ATTR_POP_VLAN] = 0,
             [OVS_ACTION_ATTR_SET] = (u32)-1,
             [OVS_ACTION_ATTR_SET_MASKED] = (u32)-1,
             [OVS_ACTION_ATTR_SAMPLE] = (u32)-1,
             [OVS_ACTION_ATTR_HASH] = sizeof(struct ovs_action_hash),
             [OVS_ACTION_ATTR_CT] = (u32)-1,
             [OVS_ACTION_ATTR_CT_CLEAR] = 0,
             [OVS_ACTION_ATTR_TRUNC] = sizeof(struct ovs_action_trunc),
             [OVS_ACTION_ATTR_PUSH_ETH] = sizeof(struct ovs_action_push_eth),
             [OVS_ACTION_ATTR_POP_ETH] = 0,
             [OVS_ACTION_ATTR_PUSH_NSH] = (u32)-1,
             [OVS_ACTION_ATTR_POP_NSH] = 0,
         };
         const struct ovs_action_push_vlan *vlan;
         int type = nla_type(a);
         bool skip_copy;

         if (type > OVS_ACTION_ATTR_MAX ||
             (action_lens[type] != nla_len(a) &&
              action_lens[type] != (u32)-1))
             return -EINVAL;

         skip_copy = false;
         switch (type) {
         case OVS_ACTION_ATTR_UNSPEC:
             return -EINVAL;

         case OVS_ACTION_ATTR_USERSPACE:
             err = validate_userspace(a);
             if (err)
                 return err;
             break;

         case OVS_ACTION_ATTR_OUTPUT:
             if (nla_get_u32(a) >= DP_MAX_PORTS)
                 return -EINVAL;
             break;

         case OVS_ACTION_ATTR_TRUNC: {
             const struct ovs_action_trunc *trunc = nla_data(a);

             if (trunc->max_len < ETH_HLEN)
                 return -EINVAL;
             break;
         }

         case OVS_ACTION_ATTR_HASH: {
             const struct ovs_action_hash *act_hash = nla_data(a);

             switch (act_hash->hash_alg) {
             case OVS_HASH_ALG_L4:
                 break;
             default:
                 return  -EINVAL;
             }

             break;
         }

         case OVS_ACTION_ATTR_POP_VLAN:
             if (mac_proto != MAC_PROTO_ETHERNET)
                 return -EINVAL;
             vlan_tci = htons(0);
             break;

         case OVS_ACTION_ATTR_PUSH_VLAN:
             if (mac_proto != MAC_PROTO_ETHERNET)
                 return -EINVAL;
             vlan = nla_data(a);
             if (!eth_type_vlan(vlan->vlan_tpid))
                 return -EINVAL;
             if (!(vlan->vlan_tci & htons(VLAN_TAG_PRESENT)))
                 return -EINVAL;
             vlan_tci = vlan->vlan_tci;
             break;

         case OVS_ACTION_ATTR_RECIRC:
             break;

         case OVS_ACTION_ATTR_PUSH_MPLS: {
             const struct ovs_action_push_mpls *mpls = nla_data(a);

             if (!eth_p_mpls(mpls->mpls_ethertype))
                 return -EINVAL;
             /* Prohibit push MPLS other than to a white list
              * for packets that have a known tag order.
              */
             if (vlan_tci & htons(VLAN_TAG_PRESENT) ||
                 (eth_type != htons(ETH_P_IP) &&
                  eth_type != htons(ETH_P_IPV6) &&
                  eth_type != htons(ETH_P_ARP) &&
                  eth_type != htons(ETH_P_RARP) &&
                  !eth_p_mpls(eth_type)))
                 return -EINVAL;
             eth_type = mpls->mpls_ethertype;
             break;
         }

         case OVS_ACTION_ATTR_POP_MPLS:
             if (vlan_tci & htons(VLAN_TAG_PRESENT) ||
                 !eth_p_mpls(eth_type))
                 return -EINVAL;

             /* Disallow subsequent L2.5+ set and mpls_pop actions
              * as there is no check here to ensure that the new
              * eth_type is valid and thus set actions could
              * write off the end of the packet or otherwise
              * corrupt it.
              *
              * Support for these actions is planned using packet
              * recirculation.
              */
             eth_type = htons(0);
             break;

         case OVS_ACTION_ATTR_SET:
             err = validate_set(a, key, sfa,
                        &skip_copy, mac_proto, eth_type,
                        false, log);
             if (err)
                 return err;
             break;

         case OVS_ACTION_ATTR_SET_MASKED:
             err = validate_set(a, key, sfa,
                        &skip_copy, mac_proto, eth_type,
                        true, log);
             if (err)
                 return err;
             break;

         case OVS_ACTION_ATTR_SAMPLE: {
             bool last = nla_is_last(a, rem);

             err = validate_and_copy_sample(net, a, key, sfa,
                                eth_type, vlan_tci,
                                log, last);
             if (err)
                 return err;
             skip_copy = true;
             break;
         }

         case OVS_ACTION_ATTR_CT:
             err = ovs_ct_copy_action(net, a, key, sfa, log);
             if (err)
                 return err;
             skip_copy = true;
             break;

         case OVS_ACTION_ATTR_CT_CLEAR:
             break;

         case OVS_ACTION_ATTR_PUSH_ETH:
             /* Disallow pushing an Ethernet header if one
              * is already present */
             if (mac_proto != MAC_PROTO_NONE)
                 return -EINVAL;
             mac_proto = MAC_PROTO_NONE;
             break;

         case OVS_ACTION_ATTR_POP_ETH:
             if (mac_proto != MAC_PROTO_ETHERNET)
                 return -EINVAL;
             if (vlan_tci & htons(VLAN_TAG_PRESENT))
                 return -EINVAL;
             mac_proto = MAC_PROTO_ETHERNET;
             break;

         case OVS_ACTION_ATTR_PUSH_NSH:
             if (mac_proto != MAC_PROTO_ETHERNET) {
                 u8 next_proto;

                 next_proto = tun_p_from_eth_p(eth_type);
                 if (!next_proto)
                     return -EINVAL;
             }
             mac_proto = MAC_PROTO_NONE;
             if (!validate_nsh(nla_data(a), false, true, true))
                 return -EINVAL;
             break;

         case OVS_ACTION_ATTR_POP_NSH: {
             __be16 inner_proto;

             if (eth_type != htons(ETH_P_NSH))
                 return -EINVAL;
             inner_proto = tun_p_to_eth_p(key->nsh.base.np);
             if (!inner_proto)
                 return -EINVAL;
             if (key->nsh.base.np == TUN_P_ETHERNET)
                 mac_proto = MAC_PROTO_ETHERNET;
             else
                 mac_proto = MAC_PROTO_NONE;
             break;
         }

         default:
             OVS_NLERR(log, "Unknown Action type %d", type);
             return -EINVAL;
         }
         if (!skip_copy) {
             err = copy_action(a, sfa, log);
             if (err)
                 return err;
         }
     }

     if (rem > 0)
         return -EINVAL;

     return 0;
 }

调试信息：

场景一：

流表：
ovs-ofctl add-flow aaa 'table=0, in_port=veth2 actions=push_mpls:0x8847,set_mpls_label:800,resubmit(,10)' -O openflow15
ovs-ofctl add-flow aaa 'table=10, mpls, mpls_label=800 actions=pop_mpls:0x0800,mod_dl_src=fe:22:33:44:55:66,mod_dl_dst=11:22:33:44:55:66,output:veth3' -O openflow15

调试信息：
3月 20 16:18:30 localhost.localdomain kernel: ovs_flow_cmd_new ... ...

3月 20 16:18:30 localhost.localdomain kernel: nla_for_each_nested, type=3, key_len=12
3月 20 16:18:30 localhost.localdomain kernel: nla_for_each_nested, type=1, key_len=-1
3月 20 16:18:30 localhost.localdomain kernel: type: 3, key_len=12
3月 20 16:18:30 localhost.localdomain kernel: OVS_ACTION_ATTR_SET
3月 20 16:18:30 localhost.localdomain kernel: type: 1, key_len=-1
3月 20 16:18:30 localhost.localdomain kernel: OVS_ACTION_ATTR_OUTPUT
3月 20 16:18:30 localhost.localdomain kernel: nla_for_each_nested, type=3, key_len=12
3月 20 16:18:30 localhost.localdomain kernel: nla_for_each_nested, type=1, key_len=-1
3月 20 16:18:30 localhost.localdomain kernel: type: 3, key_len=12
3月 20 16:18:30 localhost.localdomain kernel: OVS_ACTION_ATTR_SET
3月 20 16:18:30 localhost.localdomain kernel: type: 1, key_len=-1
3月 20 16:18:30 localhost.localdomain kernel: OVS_ACTION_ATTR_OUTPUT
3月 20 16:18:30 localhost.localdomain kernel: do_execute_actions, type: 20
3月 20 16:18:30 localhost.localdomain kernel: kernel OVS_ACTION_ATTR_SET_TO_MASKED
3月 20 16:18:30 localhost.localdomain kernel: do_execute_actions, type: 1
3月 20 16:18:30 localhost.localdomain kernel: kernel OVS_ACTION_ATTR_OUTPUT
3月 20 16:18:30 localhost.localdomain kernel: not find ovs flows ... ...
3月 20 16:18:30 localhost.localdomain kernel: queue_userspace_packet ... ...
3月 20 16:18:30 localhost.localdomain kernel: ovs_flow_cmd_new ... ...

场景二：

流表：
ovs-ofctl add-flow aaa 'table=0, in_port=veth2 actions=push_mpls:0x8847,set_mpls_label:800,output:veth3' -O openflow15
ovs-ofctl add-flow aaa 'table=0, in_port=veth4, mpls, mpls_label=800 actions=pop_mpls:0x0800,mod_dl_src=fe:22:33:44:55:66,mod_dl_dst=11:22:33:44:55:66,output:veth5' -O openflow15

调试信息：
3月 20 16:30:27 localhost.localdomain kernel: ovs_flow_cmd_new ... ...
3月 20 16:30:27 localhost.localdomain kernel: nla_for_each_nested, type=9, key_len=12796
3月 20 16:30:27 localhost.localdomain kernel: nla_for_each_nested, type=1, key_len=-1
3月 20 16:30:27 localhost.localdomain kernel: type: 9, key_len=12796
3月 20 16:30:27 localhost.localdomain kernel: OVS_ACTION_ATTR_PUSH_MPLS
3月 20 16:30:27 localhost.localdomain kernel: type: 1, key_len=-1
3月 20 16:30:27 localhost.localdomain kernel: OVS_ACTION_ATTR_OUTPUT
3月 20 16:30:27 localhost.localdomain kernel: nla_for_each_nested, type=9, key_len=12796
3月 20 16:30:27 localhost.localdomain kernel: nla_for_each_nested, type=1, key_len=-1
3月 20 16:30:27 localhost.localdomain kernel: type: 9, key_len=12796
3月 20 16:30:27 localhost.localdomain kernel: OVS_ACTION_ATTR_PUSH_MPLS
3月 20 16:30:27 localhost.localdomain kernel: type: 1, key_len=-1
3月 20 16:30:27 localhost.localdomain kernel: OVS_ACTION_ATTR_OUTPUT
3月 20 16:30:27 localhost.localdomain kernel: do_execute_actions, type: 9
3月 20 16:30:27 localhost.localdomain kernel: kernel OVS_ACTION_ATTR_PUSH_MPLS
3月 20 16:30:27 localhost.localdomain kernel: do_execute_actions, type: 1
3月 20 16:30:27 localhost.localdomain kernel: kernel OVS_ACTION_ATTR_OUTPUT
3月 20 16:30:27 localhost.localdomain kernel: not find ovs flows ... ...
3月 20 16:30:27 localhost.localdomain kernel: queue_userspace_packet ... ...
3月 20 16:30:27 localhost.localdomain kernel: ovs_flow_cmd_new ... ...
3月 20 16:30:27 localhost.localdomain kernel: nla_for_each_nested, type=3, key_len=12
3月 20 16:30:27 localhost.localdomain kernel: nla_for_each_nested, type=10, key_len=4
3月 20 16:30:27 localhost.localdomain kernel: nla_for_each_nested, type=1, key_len=1
3月 20 16:30:27 localhost.localdomain kernel: type: 3, key_len=12
3月 20 16:30:27 localhost.localdomain kernel: OVS_ACTION_ATTR_SET
3月 20 16:30:27 localhost.localdomain kernel: type: 10, key_len=4
3月 20 16:30:27 localhost.localdomain kernel: OVS_ACTION_ATTR_POP_MPLS
3月 20 16:30:27 localhost.localdomain kernel: type: 1, key_len=1
3月 20 16:30:27 localhost.localdomain kernel: OVS_ACTION_ATTR_OUTPUT
3月 20 16:30:27 localhost.localdomain kernel: nla_for_each_nested, type=3, key_len=12
3月 20 16:30:27 localhost.localdomain kernel: nla_for_each_nested, type=10, key_len=4
3月 20 16:30:27 localhost.localdomain kernel: nla_for_each_nested, type=1, key_len=1
3月 20 16:30:27 localhost.localdomain kernel: type: 3, key_len=12
3月 20 16:30:27 localhost.localdomain kernel: OVS_ACTION_ATTR_SET
3月 20 16:30:27 localhost.localdomain kernel: type: 10, key_len=4
3月 20 16:30:27 localhost.localdomain kernel: OVS_ACTION_ATTR_POP_MPLS
3月 20 16:30:27 localhost.localdomain kernel: type: 1, key_len=1
3月 20 16:30:27 localhost.localdomain kernel: OVS_ACTION_ATTR_OUTPUT
3月 20 16:30:27 localhost.localdomain kernel: do_execute_actions, type: 20
3月 20 16:30:27 localhost.localdomain kernel: kernel OVS_ACTION_ATTR_SET_TO_MASKED
3月 20 16:30:27 localhost.localdomain kernel: do_execute_actions, type: 10
3月 20 16:30:27 localhost.localdomain kernel: kernel OVS_ACTION_ATTR_POP_MPLS
3月 20 16:30:27 localhost.localdomain kernel: do_execute_actions, type: 1
3月 20 16:30:27 localhost.localdomain kernel: kernel OVS_ACTION_ATTR_OUTPUT
3月 20 16:30:27 localhost.localdomain kernel: not find ovs flows ... ...
3月 20 16:30:27 localhost.localdomain kernel: queue_userspace_packet ... ...

总结：

以上以mpls封装解封装为例（或push_vlan,pop_vlan,push_nsh,pop_nsh,push_eth,pop_eth等）

从场景一和场景二得出结论：

流表从in到out中间的过程，如果同时存在push和pop动作，ovs会跳过push和pop动作的处理，不会copy到kernel的流表项中