struct  {
    struct ovs_list list_node; 

    //匹配项，支持standard和OXM两种类型
    struct match match;
    //流表优先级
    int priority;
    //添加流表时这两项为0
    ovs_be64 cookie;         /* Cookie bits to match. */
    ovs_be64 cookie_mask;    /* 1-bit in each 'cookie' bit to match. */
    ovs_be64 new_cookie;     /* New cookie to install or UINT64_MAX. */
    bool modify_cookie;      /* Set cookie of existing flow to 'new_cookie'? */
    //流表的table id，只有删除的时候不需要指定
    uint8_t table_id;
    //操作命令，是添加、删除还是修改
    uint16_t command;
    //空闲超时时间，即流表没有报文之后多长时间销毁流表
    uint16_t idle_timeout;
    //硬超时时间，从建立起多长时间销毁流表，不论有木有报文
    uint16_t hard_timeout;
    uint32_t buffer_id;
    //出端口
    ofp_port_t out_port;
    uint32_t out_group;
    //一些操作标识，比如要不要统计等等
    enum ofputil_flow_mod_flags flags;
    uint16_t importance;     /* Eviction precedence. */
    //操作
    struct ofpact *ofpacts;  /* Series of "struct ofpact"s. */
    size_t ofpacts_len;      /* Length of ofpacts, in bytes. */
};

struct ofproto_flow_mod {
    //rculist链表，里面存储了match项，和上面的match项还是有差别的
    //上面的match结构主要是flow和mask两个结构
    //rule里面的是minimatch，里面包含了上面的两个flow，并且还有flowmap
    //rule的其他信息基本上是从上面拷贝过来的
    struct rule *temp_rule;
    struct rule_criteria criteria;
    //和actions相关的，不太明白
    struct cls_conjunction *conjs;
    size_t n_conjs;

    //以下两条直接从上面数据结构拷贝
    uint16_t command;
    bool modify_cookie;
    //允许添加流表
    bool modify_may_add_flow;
    //取自上面的flags，是否保持统计，false表示重新统计
    bool modify_keep_counts;
    enum nx_flow_update_event event;

    ovs_version_t version;

    bool learn_adds_rule;               /* Learn execution adds a rule. */
    struct rule_collection old_rules;   /* Affected rules. */
    struct rule_collection new_rules;   /* Replacement rules. */
};

struct rule {
    //包含自己的ofproto
    struct ofproto *const ofproto; /* The ofproto that contains this rule. */
    const struct cls_rule cr;      /* In owning ofproto's classifier. */
    //流表中看到的table_id
    const uint8_t table_id;        /* Index in ofproto's 'tables' array. */

    //流表状态，包括初始化、插入和删除
    enum rule_state state;

    //用于释放的引用计数
    struct ovs_refcount ref_count;

    const ovs_be64 flow_cookie; /* Immutable once rule is constructed. */
    struct hindex_node cookie_node OVS_GUARDED_BY(ofproto_mutex);

    enum ofputil_flow_mod_flags flags OVS_GUARDED;

    //对应上面的两个超时
    uint16_t hard_timeout OVS_GUARDED; /* In seconds from ->modified. */
    uint16_t idle_timeout OVS_GUARDED; /* In seconds from ->used. */

    /* Eviction precedence. */
    const uint16_t importance;

    uint8_t removed_reason;

    struct eviction_group *eviction_group OVS_GUARDED_BY(ofproto_mutex);
    struct heap_node evg_node OVS_GUARDED_BY(ofproto_mutex);

    //action操作
    const struct rule_actions * const actions;

    /* In owning meter's 'rules' list.  An empty list if there is no meter. */
    struct ovs_list meter_list_node OVS_GUARDED_BY(ofproto_mutex);

    enum nx_flow_monitor_flags monitor_flags OVS_GUARDED_BY(ofproto_mutex);
    uint64_t add_seqno OVS_GUARDED_BY(ofproto_mutex);
    uint64_t modify_seqno OVS_GUARDED_BY(ofproto_mutex);

    struct ovs_list expirable OVS_GUARDED_BY(ofproto_mutex);

    long long int created OVS_GUARDED; /* Creation time. */

    long long int modified OVS_GUARDED; /* Time of last modification. */
};

struct ofproto {
    struct hmap_node hmap_node; /* In global 'all_ofprotos' hmap. */
    const struct ofproto_class *ofproto_class;
    char *type;                 /* Datapath type. */
    char *name;                 /* Datapath name. */

    /* Settings. */
    uint64_t fallback_dpid;     /* Datapath ID if no better choice found. */
    uint64_t datapath_id;       /* Datapath ID. */
    bool forward_bpdu;          /* Option to allow forwarding of BPDU frames
                                 * when NORMAL action is invoked. */
    char *mfr_desc;             /* Manufacturer (NULL for default). */
    char *hw_desc;              /* Hardware (NULL for default). */
    char *sw_desc;              /* Software version (NULL for default). */
    char *serial_desc;          /* Serial number (NULL for default). */
    char *dp_desc;              /* Datapath description (NULL for default). */
    enum ofputil_frag_handling frag_handling;

    /* Datapath. */
    struct hmap ports;          /* Contains "struct ofport"s. */
    struct shash port_by_name;
    struct simap ofp_requests;  /* OpenFlow port number requests. */
    uint16_t alloc_port_no;     /* Last allocated OpenFlow port number. */
    uint16_t max_ports;         /* Max possible OpenFlow port num, plus one. */
    struct hmap ofport_usage;   /* Map ofport to last used time. */
    uint64_t change_seq;        /* Change sequence for netdev status. */

    /* Flow tables. */
    long long int eviction_group_timer; /* For rate limited reheapification. */
    struct oftable *tables;
    int n_tables;
    ovs_version_t tables_version;  /* Controls which rules are visible to
                                    * table lookups. */

    /* Rules indexed on their cookie values, in all flow tables. */
    struct hindex cookies OVS_GUARDED_BY(ofproto_mutex);
    struct hmap learned_cookies OVS_GUARDED_BY(ofproto_mutex);

    /* List of expirable flows, in all flow tables. */
    struct ovs_list expirable OVS_GUARDED_BY(ofproto_mutex);

    /* Meter table.
     * OpenFlow meters start at 1.  To avoid confusion we leave the first
     * pointer in the array un-used, and index directly with the OpenFlow
     * meter_id. */
    struct ofputil_meter_features meter_features;
    struct meter **meters; /* 'meter_features.max_meter' + 1 pointers. */

    /* OpenFlow connections. */
    struct connmgr *connmgr;

    int min_mtu;                    /* Current MTU of non-internal ports. */

    /* Groups. */
    struct cmap groups;               /* Contains "struct ofgroup"s. */
    uint32_t n_groups[4] OVS_GUARDED; /* # of existing groups of each type. */
    struct ofputil_group_features ogf;

    /* Tunnel TLV mapping table. */
    OVSRCU_TYPE(struct tun_table *) metadata_tab;

    /* Variable length mf_field mapping. Stores all configured variable length
     * meta-flow fields (struct mf_field) in a switch. */
    struct vl_mff_map vl_mff_map;
};

static bool
dpcls_lookup(struct dpcls *cls, const struct netdev_flow_key keys[],
            struct dpcls_rule **rules, const size_t cnt,
            int *num_lookups_p)
{
    typedef uint32_t map_type;


    struct dpcls_subtable *subtable;

    //keys_map所有位都置1
    map_type keys_map = TYPE_MAXIMUM(map_type); /* Set all bits. */
    map_type found_map;
    uint32_t hashes[MAP_BITS];
    const struct cmap_node *nodes[MAP_BITS];

    //清除多余的位，只记录跟报文一样多的位
    if (cnt != MAP_BITS) {
        keys_map >>= MAP_BITS - cnt; /* Clear extra bits. */
    }
    memset(rules, 0, cnt * sizeof *rules);

    int lookups_match = 0, subtable_pos = 1;

    //dpcls是由众多的subtables组成，当新的规则插入时，子表根据情况动态创建。
    //每个子表都是根据掩码来区分的，我们通过key和子表的掩码进行计算，
    //找到匹配的表项，因为不会重复，所以只要找到即可停止
    //以下就是循环所有子表进行查找
    PVECTOR_FOR_EACH (subtable, &cls->subtables) {
        int i;

        //这个循环是找到keys_map是1的最低位是多少，一开始的时候肯定全是1，就是从0开始
        //然后根据报文的key和mask计算出hash存储起来，继续下一个1的位
        //直到计算出所有报文hash值，下面会去匹配表项的
        //hash值的计算可以通过cpu加速，需要cpu支持，并且编译时配置"-msse4.2"
        ULLONG_FOR_EACH_1(i, keys_map) {
            hashes[i] = netdev_flow_key_hash_in_mask(&keys[i],
                        &subtable->mask);
        }
        //从子表中进行hash值的匹配，将匹配到node的报文的bit置1到found_map
        found_map = cmap_find_batch(&subtable->rules, keys_map, hashes, nodes);
        //在找到匹配node的报文的冲突hash链中继续详细匹配报文
        ULLONG_FOR_EACH_1(i, found_map) {
            struct dpcls_rule *rule;
            //冲突链中继续检测key值是否匹配
            CMAP_NODE_FOR_EACH (rule, cmap_node, nodes[i]) {
                if (OVS_LIKELY(dpcls_rule_matches_key(rule, &keys[i]))) {
                    //找到匹配的规则，则记录一下，后面会用到
                    rules[i] = rule;
                    subtable->hit_cnt++;
                    lookups_match += subtable_pos;
                    goto next;
                }
            }
            //不匹配则将该位设置为0
            ULLONG_SET0(found_map, i);  /* Did not match. */
next:
            ;                     /* Keep Sparse happy. */
        }
        //清除已经匹配流表的位
        keys_map &= ~found_map;             /* Clear the found rules. */
        if (!keys_map) {
            if (num_lookups_p) {
                *num_lookups_p = lookups_match;
            }
            return true;              /* All found. */
        }
        subtable_pos++;
    }
    if (num_lookups_p) {
        *num_lookups_p = lookups_match;
    }
    return false;                     /* Some misses. */
}