入口在這裡，往下走,傳進去subtable有效欄位有多大
static uint32_t
dpcls_subtable_lookup_generic(struct dpcls_subtable *subtable,
                              uint32_t keys_map,
                              const struct netdev_flow_key *keys[],
                              struct dpcls_rule **rules)
{
    return lookup_generic_impl(subtable, keys_map, keys, rules,
                               subtable->mf_bits_set_unit0,
                               subtable->mf_bits_set_unit1);
}

static inline uint32_t ALWAYS_INLINE
lookup_generic_impl(struct dpcls_subtable *subtable,      // 當前的subtable
                    uint32_t keys_map,                    // miss_bit_map
                    const struct netdev_flow_key *keys[], // miss_key
                    struct dpcls_rule **rules,            // save hit_rule
                    const uint32_t bit_count_u0,         
                    const uint32_t bit_count_u1)
{
    // 有幾個包
    const uint32_t n_pkts = count_1bits(keys_map);
    ovs_assert(NETDEV_MAX_BURST >= n_pkts);
    uint32_t hashes[NETDEV_MAX_BURST];

    // 根據mask欄位的大小開空間
    const uint32_t bit_count_total = bit_count_u0 + bit_count_u1;
    // 一個batch最大是NETDEV_MAX_BURST
    const uint32_t block_count_required = bit_count_total * NETDEV_MAX_BURST;
    uint64_t *mf_masks = subtable->mf_masks;  
    int i;

    // 申請儲存一個batch報文資訊的陣列，存放
    uint64_t *blocks_scratch = get_blocks_scratch(block_count_required); 

    // 獲得每個key與當前表的mask「與運算」的結果
    ULLONG_FOR_EACH_1 (i, keys_map) {
            netdev_flow_key_flatten(keys[i],
                                    &subtable->mask, // 該表的掩碼資訊
                                    mf_masks,  // 由subtable->mask處理後的mask
                                    &blocks_scratch[i * bit_count_total],
                                    bit_count_u0,
                                    bit_count_u1);
    }

    // 算出來每一個key在該subtable裡的hash值，該hash值由「mask位元組數，key和mask與運算結果」得出
    ULLONG_FOR_EACH_1 (i, keys_map) {
        uint64_t *block_ptr = &blocks_scratch[i * bit_count_total];
        uint32_t hash = hash_add_words64(0, block_ptr, bit_count_total); 
        hashes[i] = hash_finish(hash, bit_count_total * 8); 
    }

    uint32_t found_map;
    const struct cmap_node *nodes[NETDEV_MAX_BURST];

    // 找到每個key在該subtable裡的cmap，並且返回每個key有沒有被找到，第i位是1則找到
    found_map = cmap_find_batch(&subtable->rules, keys_map, hashes, nodes);

    ULLONG_FOR_EACH_1 (i, found_map) {
        struct dpcls_rule *rule;
        // 可能不同的rule有相同的hash，看那個是匹配的
        CMAP_NODE_FOR_EACH (rule, cmap_node, nodes[i]) { 
            const uint32_t cidx = i * bit_count_total;
            /*rule->mask & keys[i]的值與rule->flow相比較*/
            uint32_t match = netdev_rule_matches_key(rule, bit_count_total,
                                                     &blocks_scratch[cidx]);
            if (OVS_LIKELY(match)) {
                rules[i] = rule;
                subtable->hit_cnt++;
                goto next;
            }
        }
        ULLONG_SET0(found_map, i);  /* Did not match. */
    next:
        ; /* Keep Sparse happy. */
    }
    return found_map;
}

// 這個函數對應dpif-netdev.c裡面的dpcls_flow_key_gen_masks()
static inline void
netdev_flow_key_flatten(const struct netdev_flow_key *key,  // 要查詢的miss_key
                        const struct netdev_flow_key *mask, 
                        const uint64_t *mf_masks,
                        uint64_t *blocks_scratch,
                        const uint32_t u0_count,
                        const uint32_t u1_count)
{
    /* Load mask from subtable, mask with packet mf, popcount to get idx. */
    const uint64_t *pkt_blocks = miniflow_get_values(&key->mf);    
    const uint64_t *tbl_blocks = miniflow_get_values(&mask->mf); // 獲取miss_key和mask的miniflow

    /* Packet miniflow bits to be masked by pre-calculated mf_masks. */
    const uint64_t pkt_bits_u0 = key->mf.map.bits[0];
    const uint32_t pkt_bits_u0_pop = count_1bits(pkt_bits_u0);
    const uint64_t pkt_bits_u1 = key->mf.map.bits[1];

// 這個函數就是把miss_key與subtable的掩碼進行&運算
// 會運算出該mask在意欄位結果，放到blocks_scratch裡
    netdev_flow_key_flatten_unit(&pkt_blocks[0],   // key-mf的資料段
                                 &tbl_blocks[0],   // mask->mf的資料段
                                 &mf_masks[0],     // mask->mf->bits得來mask
                                 &blocks_scratch[0], // 存放的地址
                                 pkt_bits_u0,      // key->mf裡的bits[0]
                                 u0_count);        // mask->mf->bits[0]裡1的個數

    netdev_flow_key_flatten_unit(&pkt_blocks[pkt_bits_u0_pop], // 上邊bits[0]的已經算過了，從bits[1]開始算
                                 &tbl_blocks[u0_count],
                                 &mf_masks[u0_count],
                                 &blocks_scratch[u0_count],
                                 pkt_bits_u1,
                                 u1_count);
}

static inline void
netdev_flow_key_flatten_unit(const uint64_t *pkt_blocks, // key-mf的資料段
                             const uint64_t *tbl_blocks, // mask->mf裡的資料段
                             const uint64_t *mf_masks,   // mask->mf->bits得來mask
                             uint64_t *blocks_scratch,   // 存放到這裡
                             const uint64_t pkt_mf_bits, // key->mf裡的bits[01]
                             const uint32_t count)       // mask->mf->bits[0]裡1的個數
{

// 說一下意思，這個我們流程就是用key和subtable的mask與運算，肯定只需要與運算mask裡
// 不為0的欄位，其他的mask不關心，然後這個操作就是為了得到key對應欄位是key->mf的第幾位，
// 比如mask的bits[0]=11111, key的bits[0] = 10100, mask裡的第3個1在key裡面是第1個
// 這一位與的結果就是tbl_blocks[2]&pkt_blocks[0], 也就是怎麼找到key裡的下標0
// 就看key當前位之前有幾個1就行了。這裡這樣做的1010111，
// 藍色1之前有count_1bits(1010111 & 0001111) = 3


//  對上邊的mask舉個例子 count = 4;
//  mask->mf->bits[0] = 111010 (2進位制)
//  mf_masks = [1, 111, 1111, 11111] (2進位制);
//  pkt_mf_bits = 010100
//  blocks_scratch = [0,0,0,0,pkt_blocks[1]&tbl_blocks[4],0]
    uint32_t i;    
    for (i = 0; i < count; i++) {
        // 拿i=2舉例
        uint64_t mf_mask = mf_masks[i];             // mf_mask = 001111
        uint64_t idx_bits = mf_mask & pkt_mf_bits;  // idx_bits = 000100
        const uint32_t pkt_idx = count_1bits(idx_bits); // pkt_idx = 1

        uint64_t pkt_has_mf_bit = (mf_mask + 1) & pkt_mf_bits;  // pkt_has_mf_bit = 010000
        // 是否求掩碼：mask當前位對應的key的欄位，如果key在當前位是0，下邊算掩碼就會變成0
        uint64_t no_bit = ((!pkt_has_mf_bit) > 0) - 1; // 2^64 - 1

        // mask裡第i個欄位與運算key對應的欄位
        blocks_scratch[i] = pkt_blocks[pkt_idx] & tbl_blocks[i] & no_bit; // 
    }
}

unsigned long
cmap_find_batch(const struct cmap *cmap, unsigned long map,
                uint32_t hashes[], const struct cmap_node *nodes[])
{
    const struct cmap_impl *impl = cmap_get_impl(cmap); 
    unsigned long result = map;
    int i;
    // 每一位就是一個包，一位元組8個包
    uint32_t h1s[sizeof map * CHAR_BIT]; 
    const struct cmap_bucket *b1s[sizeof map * CHAR_BIT];
    const struct cmap_bucket *b2s[sizeof map * CHAR_BIT];
    uint32_t c1s[sizeof map * CHAR_BIT];

    // 每個impl裡桶的數量為impl->mask+1
    // 為什麼mask是桶的個數減1:因為下標從0開始，找下表的時候直接(hash & impl->mask)就行了

    // 至於為什麼開兩個？因為buckets存放的方法也是一個值對應兩個hash
    // 第一次hash1 = rehash(impl->basis, hash), 找buckets[hash1 & impl->mask], 遍歷裡面CMAP_K個元素
    // 第二次hash2 = other_hash(hash1), 找buckets[hash2 & impl->mask], 遍歷裡面CMAP_K個元素
    

    /* Compute hashes and prefetch 1st buckets. */
    ULLONG_FOR_EACH_1(i, map) {
        h1s[i] = rehash(impl, hashes[i]);            
        b1s[i] = &impl->buckets[h1s[i] & impl->mask];
        OVS_PREFETCH(b1s[i]);
    }
    /* Lookups, Round 1. Only look up at the first bucket. */
    ULLONG_FOR_EACH_1(i, map) {
        uint32_t c1;
        const struct cmap_bucket *b1 = b1s[i];
        const struct cmap_node *node;

        do {
            c1 = read_even_counter(b1);
            // 找一下這個cmap_bucket裡面有沒有相同hash的
            node = cmap_find_in_bucket(b1, hashes[i]);
        } while (OVS_UNLIKELY(counter_changed(b1, c1)));

        if (!node) {
            /* Not found (yet); Prefetch the 2nd bucket. */
            b2s[i] = &impl->buckets[other_hash(h1s[i]) & impl->mask];
            OVS_PREFETCH(b2s[i]);
            c1s[i] = c1; /* We may need to check this after Round 2. */
            continue;
        }
        /* Found. */
        ULLONG_SET0(map, i); /* Ignore this on round 2. */
        OVS_PREFETCH(node);
        nodes[i] = node;
    }
    /* Round 2. Look into the 2nd bucket, if needed. */
    ULLONG_FOR_EACH_1(i, map) {
        uint32_t c2;
        const struct cmap_bucket *b2 = b2s[i];
        const struct cmap_node *node;

        do {
            c2 = read_even_counter(b2);
            node = cmap_find_in_bucket(b2, hashes[i]);
        } while (OVS_UNLIKELY(counter_changed(b2, c2)));

        if (!node) {
            // 可能被修改了，
            if (OVS_UNLIKELY(counter_changed(b1s[i], c1s[i]))) {
                node = cmap_find__(b1s[i], b2s[i], hashes[i]);
                if (node) {
                    goto found;
                }
            }
            /* Not found. */
            ULLONG_SET0(result, i); /* Fix the result. */
            continue;
        }
found:
        OVS_PREFETCH(node);
        nodes[i] = node;
    }
    return result;
}