先把程式碼貼出來，後續再做細化解釋和總結

void ovs_dp_process_packet_with_key(struct sk_buff *skb,

   struct sw_flow_key *pkt_key,
   bool recirc)
{
const struct vport *p = OVS_CB(skb)->input_vport;
struct datapath *dp = p->dp;
struct sw_flow *flow;
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, pkt_key, skb_get_hash(skb),
&n_mask_hit);
if (unlikely(!flow)) {
struct dp_upcall_info upcall;


upcall.cmd = OVS_PACKET_CMD_MISS;
upcall.key = pkt_key;
upcall.userdata = NULL;
upcall.portid = ovs_vport_find_upcall_portid(p, skb);
ovs_dp_upcall(dp, skb, &upcall);
consume_skb(skb);
stats_counter = &stats->n_missed;
goto out;
}


OVS_CB(skb)->pkt_key = pkt_key;
OVS_CB(skb)->flow = flow;


ovs_flow_stats_update(OVS_CB(skb)->flow, pkt_key->tp.flags, skb);
ovs_execute_actions(dp, skb, recirc);
stats_counter = &stats->n_hit;


out:
/* Update datapath statistics. */
u64_stats_update_begin(&stats->sync);
(*stats_counter)++;
stats->n_mask_hit += n_mask_hit;
u64_stats_update_end(&stats->sync);
}


/* Must be called with rcu_read_lock. */
void ovs_dp_process_received_packet(struct vport *p, struct sk_buff *skb)
{
int error;
struct sw_flow_key key;


OVS_CB(skb)->input_vport = p;


/* Extract flow from 'skb' into 'key'. */
error = ovs_flow_key_extract(skb, &key);
if (unlikely(error)) {
kfree_skb(skb);
return;
}
ovs_dp_process_packet_with_key(skb, &key, false);
}


int ovs_dp_upcall(struct datapath *dp, struct sk_buff *skb,
 const struct dp_upcall_info *upcall_info)
{
struct dp_stats_percpu *stats;
int err;


if (upcall_info->portid == 0) {
err = -ENOTCONN;
goto err;
}


if (!skb_is_gso(skb))
err = queue_userspace_packet(dp, skb, upcall_info);
else
err = queue_gso_packets(dp, skb, upcall_info);
if (err)
goto err;


return 0;


err:
stats = this_cpu_ptr(dp->stats_percpu);


u64_stats_update_begin(&stats->sync);
stats->n_lost++;
u64_stats_update_end(&stats->sync);


return err;
}


static int queue_gso_packets(struct datapath *dp, struct sk_buff *skb,
    const struct dp_upcall_info *upcall_info)
{
unsigned short gso_type = skb_shinfo(skb)->gso_type;
struct dp_upcall_info later_info;
struct sw_flow_key later_key;
struct sk_buff *segs, *nskb;
struct ovs_skb_cb ovs_cb;
int err;


ovs_cb = *OVS_CB(skb);
segs = __skb_gso_segment(skb, NETIF_F_SG, false);
*OVS_CB(skb) = ovs_cb;
if (IS_ERR(segs))
return PTR_ERR(segs);
if (segs == NULL)
return -EINVAL;


/* Queue all of the segments. */
skb = segs;
do {
*OVS_CB(skb) = ovs_cb;
err = queue_userspace_packet(dp, skb, upcall_info);
if (err)
break;


if (skb == segs && gso_type & SKB_GSO_UDP) {
/* The initial flow key extracted by ovs_flow_extract()
* in this case is for a first fragment, so we need to
* properly mark later fragments.
*/
later_key = *upcall_info->key;
later_key.ip.frag = OVS_FRAG_TYPE_LATER;


later_info = *upcall_info;
later_info.key = &later_key;
upcall_info = &later_info;
}
} while ((skb = skb->next));


/* Free all of the segments. */
skb = segs;
do {
nskb = skb->next;
if (err)
kfree_skb(skb);
else
consume_skb(skb);
} while ((skb = nskb));
return err;
}