19 #include <netinet/in.h> 43 return applied_hash_aces;
50 DBG(
"HASH ADD/DEL: %016llx %016llx %016llx %016llx %016llx %016llx %016llx add %d",
75 *pkey++ = *pmatch++ & *pmask++;
76 *pkey++ = *pmatch++ & *pmask++;
77 *pkey++ = *pmatch++ & *pmask++;
78 *pkey++ = *pmatch++ & *pmask++;
79 *pkey++ = *pmatch++ & *pmask++;
80 *pkey++ = *pmatch++ & *pmask++;
85 kv_val->applied_entry_index = new_index;
92 u32 index,
int is_add)
108 if(memcmp(&mte->mask, mask, sizeof(*mask)) == 0)
109 return (mte - am->ace_mask_type_pool);
120 if(~0 == mask_type_index) {
130 ASSERT(mask_type_index < 32768);
134 return mask_type_index;
151 applied_hash_aces,
u32 lc_index)
158 for (i = 0; i <
vec_len ((*applied_hash_aces)); i++)
164 u32 new_pointer =
vec_len (new_hash_applied_mask_info_vec);
166 for (search = 0; search <
vec_len (new_hash_applied_mask_info_vec);
174 vec_validate ((new_hash_applied_mask_info_vec), search);
176 if (search == new_pointer)
196 vec_free ((*hash_applied_mask_info_vec));
197 (*hash_applied_mask_info_vec) = new_hash_applied_mask_info_vec;
202 u32 applied_entry_index)
205 for (i = 0; i <
vec_len ((*pvec)); i++)
217 u32 head_index,
u32 applied_entry_index)
227 u32 head_index,
u32 applied_entry_index)
253 DBG(
"activate_applied_ace_hash_entry lc_index %d new_index %d", lc_index, new_index);
257 DBG(
"APPLY ADD KY: %016llx %016llx %016llx %016llx %016llx %016llx",
263 int res = BV (clib_bihash_search) (&am->
acl_lookup_hash, &kv, &result);
269 ASSERT(first_index != ~0);
270 DBG(
"A key already exists, with applied entry index: %d", first_index);
275 DBG(
"...advance to chained entry index: %d", last_index);
358 DBG0(
"HASH ACL apply: lc_index %d acl %d", lc_index, acl_index);
373 int base_offset =
vec_len(*applied_hash_aces);
384 clib_warning(
"BUG: trying to apply twice acl_index %d on lc_index %d, according to lc",
385 acl_index, lc_index);
389 u32 index2 =
vec_search((*hash_acl_applied_lc_index), lc_index);
391 clib_warning(
"BUG: trying to apply twice acl_index %d on lc_index %d, according to hash h-acl info",
392 acl_index, lc_index);
395 vec_add1((*hash_acl_applied_lc_index), lc_index);
413 u32 new_index = base_offset +
i;
442 u32 an_index = curr_index;
457 u32 old_index,
u32 new_index)
474 applied_hash_aces, new_index, 1);
505 DBG(
"UNAPPLY DEACTIVATE: lc_index %d applied index %d", lc_index, old_index);
543 applied_hash_aces, old_index, 0);
563 DBG0(
"HASH ACL unapply: lc_index %d acl %d", lc_index, acl_index);
573 clib_warning(
"BUG: trying to unapply unapplied acl_index %d on lc_index %d, according to lc",
574 acl_index, lc_index);
579 u32 index2 =
vec_search((*hash_acl_applied_lc_index), lc_index);
581 clib_warning(
"BUG: trying to unapply twice acl_index %d on lc_index %d, according to h-acl info",
582 acl_index, lc_index);
585 vec_del1((*hash_acl_applied_lc_index), index2);
589 for(i=0; i <
vec_len((*applied_hash_aces)); i++) {
591 DBG(
"Found applied ACL#%d at applied index %d", acl_index, i);
595 if (
vec_len((*applied_hash_aces)) <= i) {
596 DBG(
"Did not find applied ACL#%d at lc_index %d", acl_index, lc_index);
604 int tail_len =
vec_len((*applied_hash_aces)) - tail_offset;
605 DBG(
"base_offset: %d, tail_offset: %d, tail_len: %d", base_offset, tail_offset, tail_len);
609 applied_hash_aces, base_offset + i);
611 for(i=0; i < tail_len; i ++) {
614 DBG(
"UNAPPLY MOVE: lc_index %d, applied index %d -> %d", lc_index, tail_offset+i, base_offset + i);
640 int start_index =
vec_search((*applied_acls), acl_index);
642 DBG0(
"Start index for acl %d in lc_index %d is %d", acl_index, lc_index, start_index);
650 for(i =
vec_len(*applied_acls) - 1; i > start_index; i--) {
653 for(i = start_index; i <
vec_len(*applied_acls); i++) {
669 int i, byte, bit, bitnum;
671 memset (a, 0,
sizeof (a[0]));
672 for (i = 0; i < width; i++)
674 bitnum = (7 - (i & 7));
677 a->
as_u8[byte] |= bit;
691 if (port_first == port_last) {
704 memset(mask, 0,
sizeof(*mask));
758 pmatch[j] = pmatch[j] & pmask[j];
775 DBG(
"HASH ACL add : %d", acl_index);
780 memset(ha, 0,
sizeof(*ha));
785 for(i=0; i < a->
count; i++) {
788 memset(&ace_info, 0,
sizeof(ace_info));
816 DBG0(
"HASH ACL delete : %d", acl_index);
831 u32 *lc_list_copy = 0;
871 vlib_cli_output(vm,
" %3d: %016llx %016llx %016llx %016llx %016llx %016llx refcount %d",
872 mte - am->ace_mask_type_pool,
873 mte->mask.kv_40_8.key[0], mte->mask.kv_40_8.key[1], mte->mask.kv_40_8.key[2],
874 mte->mask.kv_40_8.key[3], mte->mask.kv_40_8.key[4], mte->mask.kv_40_8.value, mte->refcount);
889 if ((acl_index != ~0) && (acl_index !=
i))
902 " %4d: %016llx %016llx %016llx %016llx %016llx %016llx base mask index %d acl %d rule %d action %d\n",
903 j, m[0], m[1], m[2], m[3], m[4], m[5],
913 " %4d: acl %d ace %d acl pos %d pae index: %d",
921 " %4d: acl %d rule %d action %d bitmask-ready rule %d colliding_rules: %d next %d prev %d tail %d hitcount %lld acl_pos: %d",
935 " %4d: mask type index %d first rule index %d num_entries %d max_collisions %d",
950 if ((lc_index != ~0) && (lc_index != lci))
static void move_applied_ace_hash_entry(acl_main_t *am, u32 lc_index, applied_hash_ace_entry_t **applied_hash_aces, u32 old_index, u32 new_index)
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
static void deactivate_applied_ace_hash_entry(acl_main_t *am, u32 lc_index, applied_hash_ace_entry_t **applied_hash_aces, u32 old_index)
void acl_plugin_show_tables_mask_type(void)
static void * hash_acl_set_heap(acl_main_t *am)
void hash_acl_unapply(acl_main_t *am, u32 lc_index, int acl_index)
void acl_plugin_hash_acl_set_trace_heap(int on)
void acl_plugin_show_tables_applied_info(u32 lc_index)
void hash_acl_reapply(acl_main_t *am, u32 lc_index, int acl_index)
#define clib_error(format, args...)
void * mheap_alloc(void *memory, uword size)
static void add_colliding_rule(acl_main_t *am, applied_hash_ace_entry_t **applied_hash_aces, u32 head_index, u32 applied_entry_index)
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
static mheap_t * mheap_header(u8 *v)
#define MHEAP_FLAG_THREAD_SAFE
static u32 find_head_applied_ace_index(applied_hash_ace_entry_t **applied_hash_aces, u32 curr_index)
void hash_acl_add(acl_main_t *am, int acl_index)
u32 ** lc_index_vec_by_acl
u16 dst_port_or_code_last
static void make_port_mask(u16 *portmask, u16 port_first, u16 port_last)
u32 next_applied_entry_index
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
int clib_bihash_add_del(clib_bihash *h, clib_bihash_kv *add_v, int is_add)
Add or delete a (key,value) pair from a bi-hash table.
#define vec_new(T, N)
Create new vector of given type and length (unspecified alignment, no header).
static void activate_applied_ace_hash_entry(acl_main_t *am, u32 lc_index, applied_hash_ace_entry_t **applied_hash_aces, u32 new_index)
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
#define vec_resize(V, N)
Resize a vector (no header, unspecified alignment) Add N elements to end of given vector V...
#define vec_search(v, E)
Search a vector for the index of the entry that matches.
static void release_mask_type_index(acl_main_t *am, u32 mask_type_index)
void hash_acl_apply(acl_main_t *am, u32 lc_index, int acl_index, u32 acl_position)
static u32 assign_mask_type_index(acl_main_t *am, fa_5tuple_t *mask)
int hash_acl_exists(acl_main_t *am, int acl_index)
static void add_del_hashtable_entry(acl_main_t *am, u32 lc_index, applied_hash_ace_entry_t **applied_hash_aces, u32 index, int is_add)
collision_match_rule_t * colliding_rules
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
static void ip4_address_mask_from_width(ip4_address_t *a, u32 width)
u16 dst_port_or_code_first
hash_applied_mask_info_t ** hash_applied_mask_info_vec_by_lc_index
hash_acl_info_t * hash_acl_infos
#define pool_put(P, E)
Free an object E in pool P.
#define vec_dup(V)
Return copy of vector (no header, no alignment)
static void make_mask_and_match_from_rule(fa_5tuple_t *mask, acl_rule_t *r, hash_ace_info_t *hi)
#define vec_del1(v, i)
Delete the element at index I.
clib_bihash_48_8_t acl_lookup_hash
void show_hash_acl_hash(vlib_main_t *vm, acl_main_t *am, u32 verbose)
void acl_plugin_hash_acl_set_validate_heap(int on)
void clib_bihash_init(clib_bihash *h, char *name, u32 nbuckets, uword memory_size)
initialize a bounded index extensible hash table
u16 src_port_or_type_first
void acl_plugin_show_tables_bihash(u32 show_bihash_verbose)
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P (general version).
static void vec_del_collision_rule(collision_match_rule_t **pvec, u32 applied_entry_index)
applied_hash_acl_info_t * applied_hash_acl_info_by_lc_index
#define vec_free(V)
Free vector's memory (no header).
static void make_ip4_address_mask(ip4_address_t *addr, u8 prefix_len)
int acl_lookup_hash_initialized
static void * clib_mem_set_heap(void *heap)
void hash_acl_delete(acl_main_t *am, int acl_index)
#define clib_warning(format, args...)
#define clib_memcpy(a, b, c)
applied_hash_ace_entry_t ** hash_entry_vec_by_lc_index
static void acl_plugin_print_colliding_rule(vlib_main_t *vm, int j, collision_match_rule_t *cr)
u32 hash_lookup_hash_buckets
static void assign_mask_type_index_to_pae(acl_main_t *am, applied_hash_ace_entry_t *pae)
u16 src_port_or_type_last
static void acl_plugin_print_pae(vlib_main_t *vm, int j, applied_hash_ace_entry_t *pae)
#define MHEAP_FLAG_VALIDATE
static void acl_plugin_print_applied_mask_info(vlib_main_t *vm, int j, hash_applied_mask_info_t *mi)
static applied_hash_ace_entry_t ** get_applied_hash_aces(acl_main_t *am, u32 lc_index)
#define MHEAP_FLAG_SMALL_OBJECT_CACHE
ace_mask_type_entry_t * ace_mask_type_pool
static u32 find_mask_type_index(acl_main_t *am, fa_5tuple_t *mask)
u32 prev_applied_entry_index
static void fill_applied_hash_ace_kv(acl_main_t *am, applied_hash_ace_entry_t **applied_hash_aces, u32 lc_index, u32 new_index, clib_bihash_kv_48_8_t *kv)
acl_lookup_context_t * acl_lookup_contexts
uword hash_lookup_mheap_size
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
static void hashtable_add_del(acl_main_t *am, clib_bihash_kv_48_8_t *kv, int is_add)
static void ip6_address_mask_from_width(ip6_address_t *a, u32 width)
void mheap_validate(void *v)
#define vec_foreach(var, vec)
Vector iterator.
static void del_colliding_rule(applied_hash_ace_entry_t **applied_hash_aces, u32 head_index, u32 applied_entry_index)
u32 tail_applied_entry_index
ip4_address_t ip4_addr[2]
static void remake_hash_applied_mask_info_vec(acl_main_t *am, applied_hash_ace_entry_t **applied_hash_aces, u32 lc_index)
static void make_ip6_address_mask(ip6_address_t *addr, u8 prefix_len)
#define CLIB_CACHE_LINE_BYTES
void acl_plugin_show_tables_acl_hash_info(u32 acl_index)
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
u32 hash_lookup_hash_memory
ip6_address_t ip6_addr[2]
foreach_fa_cleaner_counter vlib_main_t * vlib_main