23 #if VALIDATION_SCAFFOLDING 37 vnet_classify_entry_t * v, * save_v;
38 u32 active_elements = 0;
61 clib_warning (
"found %u expected %u elts", active_elements,
73 vec_add1 (cm->unformat_l2_next_index_fns, fn);
80 vec_add1 (cm->unformat_ip_next_index_fns, fn);
88 vec_add1 (cm->unformat_acl_next_index_fns, fn);
96 vec_add1 (cm->unformat_policer_next_index_fns, fn);
103 vec_add1 (cm->unformat_opaque_index_fns, fn);
108 u8 * mask,
u32 nbuckets,
u32 memory_size,
115 nbuckets = 1 << (
max_log2 (nbuckets));
118 memset(t, 0,
sizeof (*t));
163 static vnet_classify_entry_t *
166 vnet_classify_entry_t * rv = 0;
168 vnet_classify_entry_##size##_t * rv##size = 0; 186 vec_validate_aligned \ 187 (rv##size, ((1<<log2_pages)*t->entries_per_page) - 1, \ 188 CLIB_CACHE_LINE_BYTES); \ 189 rv = (vnet_classify_entry_t *) rv##size; \ 213 memset (rv, 0xff, sizeof (*rv##size) * vec_len(rv)); \ 227 vnet_classify_entry_t * v)
237 v->next_free = t->
freelists[free_list_index];
244 vnet_classify_entry_t * v;
247 vnet_classify_entry_t * working_copy;
249 vnet_classify_entry_##size##_t * working_copy##size = 0; 278 working_copy##size = (void *) working_copy; \ 279 vec_validate_aligned \ 280 (working_copy##size, \ 281 ((1<<b->log2_pages)*t->entries_per_page) - 1, \ 282 CLIB_CACHE_LINE_BYTES); \ 283 working_copy = (void *) working_copy##size; \ 303 clib_memcpy (working_copy, v, \ 304 sizeof (vnet_classify_entry_##size##_t) \ 305 * (1<<b->log2_pages) \ 306 * (t->entries_per_page)); \ 315 working_bucket.as_u64 = b->
as_u64;
318 b->
as_u64 = working_bucket.as_u64;
322 static vnet_classify_entry_t *
324 vnet_classify_entry_t * old_values,
327 vnet_classify_entry_t * new_values, * v, * new_v;
345 key_minus_skip = (
u8 *) v->key;
350 new_hash &= (1<<new_log2_pages) - 1;
359 clib_memcpy (new_v, v,
sizeof (vnet_classify_entry_t)
377 vnet_classify_entry_t * add_v,
382 vnet_classify_entry_t * v, * new_v, * save_new_v, * working_copy, * save_v;
393 key_minus_skip = (
u8 *) add_v->key;
398 bucket_index = hash & (t->
nbuckets-1);
403 while (__sync_lock_test_and_set (t->
writer_lock, 1))
416 clib_memcpy (v, add_v,
sizeof (vnet_classify_entry_t) +
447 clib_memcpy (v, add_v,
sizeof (vnet_classify_entry_t) +
463 clib_memcpy (v, add_v,
sizeof (vnet_classify_entry_t) +
482 memset (v, 0xff,
sizeof (vnet_classify_entry_t) +
511 key_minus_skip = (
u8 *) add_v->key;
524 clib_memcpy (new_v, add_v,
sizeof (vnet_classify_entry_t) +
554 }) classify_data_or_mask_t;
561 vnet_classify_entry_t *
571 vnet_classify_entry_t * e = va_arg (*args, vnet_classify_entry_t *);
574 (s,
"[%u]: next_index %d advance %d opaque %d\n",
583 s =
format (s,
" hits %lld, last_heard %.2f\n",
584 e->hits, e->last_heard);
586 s =
format (s,
" entry is free\n");
593 int verbose = va_arg (*args,
int);
595 vnet_classify_entry_t * v, * save_v;
597 u64 active_elements = 0;
605 s =
format (s,
"[%d]: empty\n", i);
611 s =
format (s,
"[%d]: heap offset %d, len %d\n", i,
627 s =
format (s,
" %d: empty\n",
633 s =
format (s,
" %d: %U\n",
642 s =
format (s,
" %lld active elements\n", active_elements);
653 u32 next_table_index,
663 if (memory_size == 0)
664 return VNET_API_ERROR_INVALID_MEMORY_SIZE;
667 return VNET_API_ERROR_INVALID_VALUE;
673 *table_index = t - cm->tables;
681 #define foreach_tcp_proto_field \ 685 #define foreach_udp_proto_field \ 689 #define foreach_ip4_proto_field \ 701 u8 ** maskp = va_arg (*args,
u8 **);
703 u8 found_something = 0;
713 #define _(a) else if (unformat (input, #a)) a=1; 720 #define _(a) found_something += a; 724 if (found_something == 0)
731 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a)); 741 u8 ** maskp = va_arg (*args,
u8 **);
743 u8 found_something = 0;
753 #define _(a) else if (unformat (input, #a)) a=1; 760 #define _(a) found_something += a; 764 if (found_something == 0)
771 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a)); 785 u8 ** maskp = va_arg (*args,
u8 **);
786 u16 src_port = 0, dst_port = 0;
795 else if (
unformat (input,
"src_port"))
797 else if (
unformat (input,
"dst_port"))
803 if (!src_port && !dst_port)
820 u8 ** maskp = va_arg (*args,
u8 **);
822 u8 found_something = 0;
836 else if (
unformat (input,
"hdr_length"))
845 #define _(a) else if (unformat (input, #a)) a=1; 852 #define _(a) found_something += a; 856 if (found_something == 0)
863 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a)); 879 #define foreach_ip6_proto_field \ 888 u8 ** maskp = va_arg (*args,
u8 **);
890 u8 found_something = 0;
892 u32 ip_version_traffic_class_and_flow_label;
898 u8 traffic_class = 0;
905 else if (
unformat (input,
"traffic-class"))
907 else if (
unformat (input,
"flow-label"))
916 #define _(a) else if (unformat (input, #a)) a=1; 923 #define _(a) found_something += a; 927 if (found_something == 0)
934 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a)); 938 ip_version_traffic_class_and_flow_label = 0;
941 ip_version_traffic_class_and_flow_label |= 0xF0000000;
944 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
947 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
950 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
958 u8 ** maskp = va_arg (*args,
u8 **);
973 u8 ** maskp = va_arg (*args,
u8 **);
999 else if (
unformat (input,
"ignore-tag1"))
1001 else if (
unformat (input,
"ignore-tag2"))
1007 else if (
unformat (input,
"dot1q"))
1009 else if (
unformat (input,
"dot1ad"))
1014 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
1015 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
1018 if (tag1 || ignore_tag1 || cos1 || dot1q)
1020 if (tag2 || ignore_tag2 || cos2 || dot1ad)
1026 memset (mask, 0xff, 6);
1029 memset (mask + 6, 0xff, 6);
1042 mask[21] = mask [20] = 0xff;
1063 mask[16] = mask [17] = 0xff;
1072 mask[12] = mask [13] = 0xff;
1082 u8 ** maskp = va_arg (*args,
u8 **);
1083 u32 * skipp = va_arg (*args,
u32 *);
1084 u32 * matchp = va_arg (*args,
u32 *);
1112 if (mask || l2 || l3 || l4)
1133 for (i = 0; i <
vec_len (mask); i++)
1138 *skipp = i /
sizeof(
u32x4);
1142 while (vec_len (mask) %
sizeof (
u32x4))
1147 for (i = match*
sizeof(
u32x4); i > 0; i-=
sizeof(
u32x4))
1150 if (*tmp || *(tmp+1))
1157 _vec_len (mask) = match *
sizeof(
u32x4);
1168 #define foreach_l2_input_next \ 1170 _(ethernet, ETHERNET_INPUT) \ 1178 u32 * miss_next_indexp = va_arg (*args,
u32 *);
1184 for (i = 0; i <
vec_len (cm->unformat_l2_next_index_fns); i++)
1186 if (
unformat (input,
"%U", cm->unformat_l2_next_index_fns[i], &tmp))
1194 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;} 1207 *miss_next_indexp = next_index;
1211 #define foreach_l2_output_next \ 1217 u32 * miss_next_indexp = va_arg (*args,
u32 *);
1223 for (i = 0; i <
vec_len (cm->unformat_l2_next_index_fns); i++)
1225 if (
unformat (input,
"%U", cm->unformat_l2_next_index_fns[i], &tmp))
1233 if (unformat (input, #n)) { next_index = L2_OUTPUT_CLASSIFY_NEXT_##N; goto out;} 1246 *miss_next_indexp = next_index;
1250 #define foreach_ip_next \ 1256 u32 * miss_next_indexp = va_arg (*args,
u32 *);
1263 for (i = 0; i <
vec_len (cm->unformat_ip_next_index_fns); i++)
1265 if (
unformat (input,
"%U", cm->unformat_ip_next_index_fns[i], &tmp))
1273 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;} 1286 *miss_next_indexp = next_index;
1290 #define foreach_acl_next \ 1295 u32 * next_indexp = va_arg (*args,
u32 *);
1302 for (i = 0; i <
vec_len (cm->unformat_acl_next_index_fns); i++)
1304 if (
unformat (input,
"%U", cm->unformat_acl_next_index_fns[i], &tmp))
1312 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;} 1321 else if (
unformat (input,
"%d", &tmp))
1330 *next_indexp = next_index;
1336 u32 * next_indexp = va_arg (*args,
u32 *);
1343 for (i = 0; i <
vec_len (cm->unformat_policer_next_index_fns); i++)
1345 if (
unformat (input,
"%U", cm->unformat_policer_next_index_fns[i], &tmp))
1361 *next_indexp = next_index;
1374 u32 table_index = ~0;
1375 u32 next_table_index = ~0;
1376 u32 miss_next_index = ~0;
1377 u32 memory_size = 2<<20;
1387 else if (
unformat (input,
"buckets %d", &nbuckets))
1389 else if (
unformat (input,
"skip %d", &skip))
1391 else if (
unformat (input,
"match %d", &match))
1393 else if (
unformat (input,
"table %d", &table_index))
1396 cm, &mask, &skip, &match))
1398 else if (
unformat (input,
"memory-size %uM", &tmp))
1399 memory_size = tmp<<20;
1400 else if (
unformat (input,
"memory-size %uG", &tmp))
1401 memory_size = tmp<<30;
1402 else if (
unformat (input,
"next-table %d", &next_table_index))
1421 if (is_add && mask == 0)
1424 if (is_add && skip == ~0)
1427 if (is_add && match == ~0)
1430 if (!is_add && table_index == ~0)
1434 skip, match, next_table_index, miss_next_index,
1435 &table_index, is_add);
1449 .path =
"classify table",
1451 "classify table [miss-next|l2-miss_next|acl-miss-next <next_index>]" 1452 "\n mask <mask-value> buckets <nn> [skip <n>] [match <n>] [del]",
1459 int verbose = va_arg (*args,
int);
1460 u32 index = va_arg (*args,
u32);
1465 s =
format (s,
"%10s%10s%10s%10s",
"TableIdx",
"Sessions",
"NextTbl",
1466 "NextNode", verbose ?
"Details" :
"");
1476 s =
format (s,
"\n nbuckets %d, skip %d match %d",
1496 u32 match_index = ~0;
1503 if (
unformat (input,
"index %d", &match_index))
1505 else if (
unformat (input,
"verbose %d", &verbose))
1507 else if (
unformat (input,
"verbose"))
1515 if (match_index == ~0 || (match_index == t - cm->tables))
1516 vec_add1 (indices, t - cm->tables);
1523 for (i = 0; i <
vec_len (indices); i++)
1525 verbose, indices[i]);
1536 .path =
"show classify tables",
1537 .short_help =
"show classify tables [index <nn>]",
1543 u8 ** matchp = va_arg (*args,
u8 **);
1545 u8 * proto_header = 0;
1553 if (
unformat (input,
"src_port %d", &src_port))
1555 else if (
unformat (input,
"dst_port %d", &dst_port))
1561 h.
src_port = clib_host_to_net_u16(src_port);
1562 h.
dst_port = clib_host_to_net_u16(dst_port);
1564 memcpy(proto_header, &h,
sizeof(h));
1566 *matchp = proto_header;
1573 u8 ** matchp = va_arg (*args,
u8 **);
1580 int src = 0, dst = 0;
1588 int fragment_id = 0;
1589 u32 fragment_id_val;
1597 if (
unformat (input,
"version %d", &version_val))
1599 else if (
unformat (input,
"hdr_length %d", &hdr_length_val))
1605 else if (
unformat (input,
"proto %d", &proto_val))
1607 else if (
unformat (input,
"tos %d", &tos_val))
1609 else if (
unformat (input,
"length %d", &length_val))
1611 else if (
unformat (input,
"fragment_id %d", &fragment_id_val))
1613 else if (
unformat (input,
"ttl %d", &ttl_val))
1615 else if (
unformat (input,
"checksum %d", &checksum_val))
1621 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
1622 + ttl + checksum == 0)
1654 ip->
length = clib_host_to_net_u16 (length_val);
1660 ip->
checksum = clib_host_to_net_u16 (checksum_val);
1668 u8 ** matchp = va_arg (*args,
u8 **);
1673 u8 traffic_class = 0;
1674 u32 traffic_class_val;
1677 int src = 0, dst = 0;
1681 int payload_length = 0;
1682 u32 payload_length_val;
1685 u32 ip_version_traffic_class_and_flow_label;
1689 if (
unformat (input,
"version %d", &version_val))
1691 else if (
unformat (input,
"traffic_class %d", &traffic_class_val))
1693 else if (
unformat (input,
"flow_label %d", &flow_label_val))
1699 else if (
unformat (input,
"proto %d", &proto_val))
1701 else if (
unformat (input,
"payload_length %d", &payload_length_val))
1703 else if (
unformat (input,
"hop_limit %d", &hop_limit_val))
1709 if (version + traffic_class + flow_label + src + dst + proto +
1710 payload_length + hop_limit == 0)
1729 ip_version_traffic_class_and_flow_label = 0;
1732 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
1735 ip_version_traffic_class_and_flow_label |= (traffic_class_val & 0xFF) << 20;
1738 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
1741 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
1755 u8 ** matchp = va_arg (*args,
u8 **);
1771 u8 * tagp = va_arg (*args,
u8 *);
1776 tagp[0] = (tag>>8) & 0x0F;
1777 tagp[1] = tag & 0xFF;
1786 u8 ** matchp = va_arg (*args,
u8 **);
1811 else if (
unformat (input,
"proto %U",
1818 else if (
unformat (input,
"ignore-tag1"))
1820 else if (
unformat (input,
"ignore-tag2"))
1822 else if (
unformat (input,
"cos1 %d", &cos1_val))
1824 else if (
unformat (input,
"cos2 %d", &cos2_val))
1829 if ((src + dst + proto + tag1 + tag2 +
1830 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
1833 if (tag1 || ignore_tag1 || cos1)
1835 if (tag2 || ignore_tag2 || cos2)
1849 match[19] = tag2_val[1];
1850 match[18] = tag2_val[0];
1852 match [18] |= (cos2_val & 0x7) << 5;
1855 match[21] = proto_val & 0xff;
1856 match[20] = proto_val >> 8;
1860 match [15] = tag1_val[1];
1861 match [14] = tag1_val[0];
1864 match [14] |= (cos1_val & 0x7) << 5;
1870 match [15] = tag1_val[1];
1871 match [14] = tag1_val[0];
1874 match[17] = proto_val & 0xff;
1875 match[16] = proto_val >> 8;
1878 match [14] |= (cos1_val & 0x7) << 5;
1884 match [18] |= (cos2_val & 0x7) << 5;
1886 match [14] |= (cos1_val & 0x7) << 5;
1889 match[13] = proto_val & 0xff;
1890 match[12] = proto_val >> 8;
1901 u8 ** matchp = va_arg (*args,
u8 **);
1902 u32 table_index = va_arg (*args,
u32);
1935 if (match || l2 || l3 || l4)
1980 vnet_classify_entry_5_t _max_e __attribute__((aligned (16)));
1981 vnet_classify_entry_t * e;
1985 return VNET_API_ERROR_NO_SUCH_TABLE;
1989 e = (vnet_classify_entry_t *)&_max_e;
1990 e->next_index = hit_next_index;
1991 e->opaque_index = opaque_index;
1992 e->advance = advance;
2003 e->key[i] &= t->
mask[i];
2007 return VNET_API_ERROR_NO_SUCH_ENTRY;
2018 u32 table_index = ~0;
2019 u32 hit_next_index = ~0;
2020 u64 opaque_index = ~0;
2041 else if (
unformat (input,
"policer-hit-next %U",
2044 else if (
unformat (input,
"opaque-index %lld", &opaque_index))
2047 cm, &match, table_index))
2049 else if (
unformat (input,
"advance %d", &advance))
2051 else if (
unformat (input,
"table-index %d", &table_index))
2056 for (i = 0; i <
vec_len (cm->unformat_opaque_index_fns); i++)
2058 if (
unformat (input,
"%U", cm->unformat_opaque_index_fns[i],
2068 if (table_index == ~0)
2071 if (is_add && match == 0)
2076 opaque_index, advance, is_add);
2092 .path =
"classify session",
2094 "classify session [hit-next|l2-hit-next|" 2095 "acl-hit-next <next_index>|policer-hit-next <policer_name>]" 2096 "\n table-index <nn> match [hex] [l2] [l3 ip4] [opaque-index <index>]",
2103 u64 * opaquep = va_arg (*args,
u64 *);
2109 *opaquep = sw_if_index;
2119 u32 * next_indexp = va_arg (*args,
u32 *);
2121 u32 next_index = ~0;
2124 cm->vlib_main, &node_index))
2130 cm->vlib_main, &node_index))
2138 *next_indexp = next_index;
2146 u32 * next_indexp = va_arg (*args,
u32 *);
2151 cm->vlib_main, &node_index))
2157 cm->vlib_main, &node_index))
2165 *next_indexp = next_index;
2173 u32 * next_indexp = va_arg (*args,
u32 *);
2178 cm->vlib_main, &node_index))
2183 *next_indexp = next_index;
2193 u32 * next_indexp = va_arg (*args,
u32 *);
2198 cm->vlib_main, &node_index))
2203 *next_indexp = next_index;
2249 classify_data_or_mask_t * mask;
2250 classify_data_or_mask_t * data;
2251 u8 *mp = 0, *dp = 0;
2253 vnet_classify_entry_t * e;
2256 u32 table_index = ~0;
2259 u32 memory_size = 64<<20;
2262 src.
as_u32 = clib_net_to_host_u32 (0x0100000A);
2265 if (
unformat (input,
"sessions %d", &sessions))
2269 else if (
unformat (input,
"buckets %d", &buckets))
2271 else if (
unformat (input,
"memory-size %uM", &tmp))
2272 memory_size = tmp<<20;
2273 else if (
unformat (input,
"memory-size %uG", &tmp))
2274 memory_size = tmp<<30;
2277 else if (
unformat (input,
"table %d", &table_index))
2286 mask = (classify_data_or_mask_t *) mp;
2287 data = (classify_data_or_mask_t *) dp;
2289 data->ip.src_address.as_u32 = src.
as_u32;
2292 memset (&mask->ip.src_address, 0xff, 4);
2296 if (table_index != ~0)
2321 for (i = 0; i < sessions; i++)
2332 tmp = clib_net_to_host_u32 (data->ip.src_address.as_u32) + 1;
2333 data->ip.src_address.as_u32 = clib_net_to_host_u32 (tmp);
2346 for (i = 0; i < sessions; i++)
2348 u8 * key_minus_skip;
2357 ASSERT (e->opaque_index == (i+100));
2359 key_minus_skip = (
u8 *)e->key;
2370 tmp = clib_net_to_host_u32 (data->ip.src_address.as_u32) + 1;
2371 data->ip.src_address.as_u32 = clib_net_to_host_u32 (tmp);
2385 .path =
"test classify",
2387 "test classify [src <ip>] [sessions <nn>] [buckets <nn>] [table <nn>] [del]",
u64 vnet_classify_hash_packet(vnet_classify_table_t *t, u8 *h)
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
vnet_classify_entry_t ** working_copies
void clib_mem_validate(void)
uword unformat_classify_mask(unformat_input_t *input, va_list *args)
sll srl srl sll sra u16x4 i
void rogue(vnet_classify_table_t *t)
static clib_error_t * show_classify_tables_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
static vnet_classify_entry_t * vnet_classify_find_entry_inline(vnet_classify_table_t *t, u8 *h, u64 hash, f64 now)
void * mheap_alloc(void *memory, uword size)
#define VNET_CLASSIFY_ENTRY_FREE
static u8 * format_vnet_classify_table(u8 *s, va_list *args)
uword unformat_vlan_tag(unformat_input_t *input, va_list *args)
static clib_error_t * classify_table_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
unformat_function_t unformat_vnet_sw_interface
#define vec_validate_aligned(V, I, A)
Make sure vector is long enough for given index (no header, specified alignment)
#define foreach_ip6_proto_field
void vnet_classify_register_unformat_acl_next_index_fn(unformat_function_t *fn)
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
u8 * format_mheap(u8 *s, va_list *va)
static uword min_log2(uword x)
vlib_node_registration_t ip4_classify_node
(constructor) VLIB_REGISTER_NODE (ip4_classify_node)
uword unformat_l2_output_next_index(unformat_input_t *input, va_list *args)
Adjacency to drop this packet.
vnet_main_t * vnet_get_main(void)
void mv(vnet_classify_table_t *t)
vlib_node_registration_t l2_input_classify_node
(constructor) VLIB_REGISTER_NODE (l2_input_classify_node)
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
#define VLIB_INIT_FUNCTION(x)
int vnet_classify_add_del(vnet_classify_table_t *t, vnet_classify_entry_t *add_v, int is_add)
static clib_error_t * classify_session_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
uword unformat_l2_mask(unformat_input_t *input, va_list *args)
vlib_node_registration_t l2_output_classify_node
(constructor) VLIB_REGISTER_NODE (l2_output_classify_node)
static uword unformat_l2_input_next_node(unformat_input_t *input, va_list *args)
uword unformat_classify_match(unformat_input_t *input, va_list *args)
vnet_classify_table_t * vnet_classify_new_table(vnet_classify_main_t *cm, u8 *mask, u32 nbuckets, u32 memory_size, u32 skip_n_vectors, u32 match_n_vectors)
#define foreach_ip4_proto_field
#define clib_warning(format, args...)
static uword unformat_opaque_sw_if_index(unformat_input_t *input, va_list *args)
static int vnet_classify_entry_is_free(vnet_classify_entry_t *e)
static u64 vnet_classify_hash_packet_inline(vnet_classify_table_t *t, u8 *h)
uword unformat_l4_match(unformat_input_t *input, va_list *args)
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
uword unformat_ip4_mask(unformat_input_t *input, va_list *args)
int vnet_classify_add_del_table(vnet_classify_main_t *cm, u8 *mask, u32 nbuckets, u32 memory_size, u32 skip, u32 match, u32 next_table_index, u32 miss_next_index, u32 *table_index, int is_add)
uword unformat_l2_input_next_index(unformat_input_t *input, va_list *args)
void vnet_classify_delete_table_index(vnet_classify_main_t *cm, u32 table_index)
uword unformat_ip6_mask(unformat_input_t *input, va_list *args)
uword os_get_cpu_number(void)
#define pool_put(P, E)
Free an object E in pool P.
void vnet_classify_register_unformat_opaque_index_fn(unformat_function_t *fn)
static vnet_classify_entry_t * vnet_classify_entry_at_index(vnet_classify_table_t *t, vnet_classify_entry_t *e, u32 index)
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
uword unformat_policer_next_index(unformat_input_t *input, va_list *args)
vlib_node_registration_t ip4_inacl_node
(constructor) VLIB_REGISTER_NODE (ip4_inacl_node)
#define foreach_udp_proto_field
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P (general version).
uword unformat_udp_mask(unformat_input_t *input, va_list *args)
static uword vnet_classify_get_offset(vnet_classify_table_t *t, vnet_classify_entry_t *v)
static u8 * format_classify_entry(u8 *s, va_list *args)
uword unformat_l2_match(unformat_input_t *input, va_list *args)
vnet_classify_bucket_t saved_bucket
static uword unformat_acl_next_node(unformat_input_t *input, va_list *args)
vlib_node_registration_t ip6_inacl_node
(constructor) VLIB_REGISTER_NODE (ip6_inacl_node)
#define vec_free(V)
Free vector's memory (no header).
uword unformat_acl_next_index(unformat_input_t *input, va_list *args)
static void * clib_mem_set_heap(void *heap)
static uword unformat_ip_next_node(unformat_input_t *input, va_list *args)
u8 * format_classify_table(u8 *s, va_list *args)
#define clib_memcpy(a, b, c)
uword unformat_l3_match(unformat_input_t *input, va_list *args)
uword unformat_ip4_match(unformat_input_t *input, va_list *args)
typedef CLIB_PACKED(struct{ethernet_header_t eh;ip4_header_t ip;})
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
static clib_error_t * vnet_classify_init(vlib_main_t *vm)
#define VLIB_CLI_COMMAND(x,...)
struct _vnet_classify_main vnet_classify_main_t
static uword unformat_l2_output_next_node(unformat_input_t *input, va_list *args)
static void make_working_copy(vnet_classify_table_t *t, vnet_classify_bucket_t *b)
uword unformat_l3_mask(unformat_input_t *input, va_list *args)
uword unformat_ethernet_address(unformat_input_t *input, va_list *args)
#define vec_delete(V, N, M)
Delete N elements starting at element M.
uword unformat_ip6_match(unformat_input_t *input, va_list *args)
#define vec_append(v1, v2)
Append v2 after v1.
uword unformat_ip_next_index(unformat_input_t *input, va_list *args)
vnet_classify_main_t vnet_classify_main
int vnet_classify_add_del_session(vnet_classify_main_t *cm, u32 table_index, u8 *match, u32 hit_next_index, u32 opaque_index, i32 advance, int is_add)
static int vnet_classify_entry_is_busy(vnet_classify_entry_t *e)
static clib_error_t * test_classify_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
uword unformat_tcp_mask(unformat_input_t *input, va_list *args)
uword unformat_ethernet_type_host_byte_order(unformat_input_t *input, va_list *args)
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
vnet_classify_bucket_t * buckets
void vnet_classify_register_unformat_ip_next_index_fn(unformat_function_t *fn)
static uword max_log2(uword x)
uword unformat_l4_mask(unformat_input_t *input, va_list *args)
#define vec_append_aligned(v1, v2, align)
Append v2 after v1.
volatile u32 * writer_lock
static vnet_classify_entry_t * vnet_classify_entry_alloc(vnet_classify_table_t *t, u32 log2_pages)
unformat_function_t unformat_vlib_node
static void vnet_classify_entry_free(vnet_classify_table_t *t, vnet_classify_entry_t *v)
static void * clib_mem_alloc_aligned(uword size, uword align)
#define foreach_l2_output_next
#define foreach_l2_input_next
#define CLIB_MEMORY_BARRIER()
void vnet_classify_register_unformat_policer_next_index_fn(unformat_function_t *fn)
#define clib_error_return(e, args...)
vlib_node_registration_t ip6_classify_node
(constructor) VLIB_REGISTER_NODE (ip6_classify_node)
#define foreach_tcp_proto_field
#define CLIB_CACHE_LINE_BYTES
vnet_classify_entry_t ** freelists
vnet_classify_entry_t * vnet_classify_find_entry(vnet_classify_table_t *t, u8 *h, u64 hash, f64 now)
static vnet_classify_entry_t * split_and_rehash(vnet_classify_table_t *t, vnet_classify_entry_t *old_values, u32 new_log2_pages)
void vnet_classify_register_unformat_l2_next_index_fn(unformat_function_t *fn)
static vnet_classify_entry_t * vnet_classify_get_entry(vnet_classify_table_t *t, uword offset)