24 #if VALIDATION_SCAFFOLDING 40 vnet_classify_entry_t *
v, *save_v;
41 u32 active_elements = 0;
64 clib_warning (
"found %u expected %u elts", active_elements,
84 vec_add1 (cm->unformat_l2_next_index_fns, fn);
92 vec_add1 (cm->unformat_ip_next_index_fns, fn);
100 vec_add1 (cm->unformat_acl_next_index_fns, fn);
109 vec_add1 (cm->unformat_policer_next_index_fns, fn);
117 vec_add1 (cm->unformat_opaque_index_fns, fn);
123 u32 skip_n_vectors,
u32 match_n_vectors)
128 nbuckets = 1 << (
max_log2 (nbuckets));
131 memset (t, 0,
sizeof (*t));
158 u32 table_index,
int del_chain)
178 static vnet_classify_entry_t *
181 vnet_classify_entry_t *rv = 0;
206 memset (rv, 0xff, required_length);
225 vnet_classify_entry_t *
v;
228 vnet_classify_entry_t *working_copy;
230 int working_copy_length, required_length;
255 if (required_length > working_copy_length)
270 working_bucket.as_u64 = b->
as_u64;
273 b->
as_u64 = working_bucket.as_u64;
277 static vnet_classify_entry_t *
279 vnet_classify_entry_t * old_values,
u32 old_log2_pages,
282 vnet_classify_entry_t *new_values, *
v, *new_v;
283 int i, j, length_in_entries;
288 for (i = 0; i < length_in_entries; i++)
298 key_minus_skip = (
u8 *) v->key;
303 new_hash &= (1 << new_log2_pages) - 1;
312 clib_memcpy (new_v, v,
sizeof (vnet_classify_entry_t)
328 static vnet_classify_entry_t *
330 vnet_classify_entry_t * old_values,
331 u32 old_log2_pages,
u32 new_log2_pages)
333 vnet_classify_entry_t *new_values, *
v, *new_v;
334 int i, j, new_length_in_entries, old_length_in_entries;
341 for (i = 0; i < old_length_in_entries; i++)
347 for (; j < new_length_in_entries; j++)
353 clib_warning (
"BUG: linear rehash new entry not free!");
356 clib_memcpy (new_v, v,
sizeof (vnet_classify_entry_t)
411 vnet_classify_entry_t * add_v,
int is_add)
415 vnet_classify_entry_t *
v, *new_v, *save_new_v, *working_copy, *save_v;
421 u32 old_log2_pages, new_log2_pages;
424 int resplit_once = 0;
425 int mark_bucket_linear;
429 key_minus_skip = (
u8 *) add_v->key;
434 bucket_index = hash & (t->
nbuckets - 1);
439 while (__sync_lock_test_and_set (t->
writer_lock, 1))
452 clib_memcpy (v, add_v,
sizeof (vnet_classify_entry_t) +
474 limit *= (1 << b->log2_pages);
484 for (i = 0; i < limit; i++)
491 clib_memcpy (v, add_v,
sizeof (vnet_classify_entry_t) +
502 for (i = 0; i < limit; i++)
508 clib_memcpy (v, add_v,
sizeof (vnet_classify_entry_t) +
523 for (i = 0; i < limit; i++)
531 memset (v, 0xff,
sizeof (vnet_classify_entry_t) +
547 new_log2_pages = old_log2_pages + 1;
553 mark_bucket_linear = 0;
577 mark_bucket_linear = 1;
584 key_minus_skip = (
u8 *) add_v->key;
589 new_hash &= (1 << new_log2_pages) - 1;
592 if (mark_bucket_linear)
594 limit *= (1 << new_log2_pages);
598 for (i = 0; i < limit; i++)
604 clib_memcpy (new_v, add_v,
sizeof (vnet_classify_entry_t) +
642 }) classify_data_or_mask_t;
651 vnet_classify_entry_t *
662 vnet_classify_entry_t *e = va_arg (*args, vnet_classify_entry_t *);
665 (s,
"[%u]: next_index %d advance %d opaque %d action %d metadata %d\n",
667 e->opaque_index, e->action, e->metadata);
674 s =
format (s,
" hits %lld, last_heard %.2f\n",
675 e->hits, e->last_heard);
677 s =
format (s,
" entry is free\n");
685 int verbose = va_arg (*args,
int);
687 vnet_classify_entry_t *
v, *save_v;
689 u64 active_elements = 0;
697 s =
format (s,
"[%d]: empty\n", i);
703 s =
format (s,
"[%d]: heap offset %d, elts %d, %s\n", i,
720 s =
format (s,
" %d: empty\n",
726 s =
format (s,
" %d: %U\n",
735 s =
format (s,
" %lld active elements\n", active_elements);
748 u32 next_table_index,
751 u8 current_data_flag,
752 i16 current_data_offset,
753 int is_add,
int del_chain)
759 if (*table_index == ~0)
761 if (memory_size == 0)
762 return VNET_API_ERROR_INVALID_MEMORY_SIZE;
765 return VNET_API_ERROR_INVALID_VALUE;
773 *table_index = t - cm->tables;
789 #define foreach_tcp_proto_field \ 793 #define foreach_udp_proto_field \ 797 #define foreach_ip4_proto_field \ 810 u8 **maskp = va_arg (*args,
u8 **);
812 u8 found_something = 0;
822 #define _(a) else if (unformat (input, #a)) a=1; 829 #define _(a) found_something += a; 833 if (found_something == 0)
840 #define _(a) if (a) memset (&tcp->a, 0xff, sizeof (tcp->a)); 851 u8 **maskp = va_arg (*args,
u8 **);
853 u8 found_something = 0;
863 #define _(a) else if (unformat (input, #a)) a=1; 870 #define _(a) found_something += a; 874 if (found_something == 0)
881 #define _(a) if (a) memset (&udp->a, 0xff, sizeof (udp->a)); 897 u8 **maskp = va_arg (*args,
u8 **);
898 u16 src_port = 0, dst_port = 0;
907 else if (
unformat (input,
"src_port"))
909 else if (
unformat (input,
"dst_port"))
915 if (!src_port && !dst_port)
933 u8 **maskp = va_arg (*args,
u8 **);
935 u8 found_something = 0;
949 else if (
unformat (input,
"hdr_length"))
958 #define _(a) else if (unformat (input, #a)) a=1; 965 #define _(a) found_something += a; 969 if (found_something == 0)
976 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a)); 992 #define foreach_ip6_proto_field \ 1002 u8 **maskp = va_arg (*args,
u8 **);
1004 u8 found_something = 0;
1006 u32 ip_version_traffic_class_and_flow_label;
1008 #define _(a) u8 a=0; 1012 u8 traffic_class = 0;
1019 else if (
unformat (input,
"traffic-class"))
1021 else if (
unformat (input,
"flow-label"))
1027 else if (
unformat (input,
"proto"))
1030 #define _(a) else if (unformat (input, #a)) a=1; 1037 #define _(a) found_something += a; 1041 if (found_something == 0)
1048 #define _(a) if (a) memset (&ip->a, 0xff, sizeof (ip->a)); 1052 ip_version_traffic_class_and_flow_label = 0;
1055 ip_version_traffic_class_and_flow_label |= 0xF0000000;
1058 ip_version_traffic_class_and_flow_label |= 0x0FF00000;
1061 ip_version_traffic_class_and_flow_label |= 0x000FFFFF;
1064 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
1073 u8 **maskp = va_arg (*args,
u8 **);
1090 u8 **maskp = va_arg (*args,
u8 **);
1111 else if (
unformat (input,
"proto"))
1117 else if (
unformat (input,
"ignore-tag1"))
1119 else if (
unformat (input,
"ignore-tag2"))
1125 else if (
unformat (input,
"dot1q"))
1127 else if (
unformat (input,
"dot1ad"))
1132 if ((src + dst + proto + tag1 + tag2 + dot1q + dot1ad +
1133 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
1136 if (tag1 || ignore_tag1 || cos1 || dot1q)
1138 if (tag2 || ignore_tag2 || cos2 || dot1ad)
1144 memset (mask, 0xff, 6);
1147 memset (mask + 6, 0xff, 6);
1160 mask[21] = mask[20] = 0xff;
1181 mask[16] = mask[17] = 0xff;
1190 mask[12] = mask[13] = 0xff;
1199 u8 **maskp = va_arg (*args,
u8 **);
1200 u32 *skipp = va_arg (*args,
u32 *);
1201 u32 *matchp = va_arg (*args,
u32 *);
1231 if (mask || l2 || l3 || l4)
1252 for (i = 0; i <
vec_len (mask); i++)
1257 *skipp = i /
sizeof (
u32x4);
1261 while (vec_len (mask) %
sizeof (
u32x4))
1266 for (i = match *
sizeof (
u32x4); i > 0; i -=
sizeof (
u32x4))
1269 if (*tmp || *(tmp + 1))
1276 _vec_len (mask) = match *
sizeof (
u32x4);
1287 #define foreach_l2_input_next \ 1289 _(ethernet, ETHERNET_INPUT) \ 1298 u32 *miss_next_indexp = va_arg (*args,
u32 *);
1304 for (i = 0; i <
vec_len (cm->unformat_l2_next_index_fns); i++)
1306 if (
unformat (input,
"%U", cm->unformat_l2_next_index_fns[i], &tmp))
1314 if (unformat (input, #n)) { next_index = L2_INPUT_CLASSIFY_NEXT_##N; goto out;} 1327 *miss_next_indexp = next_index;
1331 #define foreach_l2_output_next \ 1338 u32 *miss_next_indexp = va_arg (*args,
u32 *);
1344 for (i = 0; i <
vec_len (cm->unformat_l2_next_index_fns); i++)
1346 if (
unformat (input,
"%U", cm->unformat_l2_next_index_fns[i], &tmp))
1354 if (unformat (input, #n)) { next_index = L2_OUTPUT_CLASSIFY_NEXT_##N; goto out;} 1367 *miss_next_indexp = next_index;
1371 #define foreach_ip_next \ 1378 u32 *miss_next_indexp = va_arg (*args,
u32 *);
1385 for (i = 0; i <
vec_len (cm->unformat_ip_next_index_fns); i++)
1387 if (
unformat (input,
"%U", cm->unformat_ip_next_index_fns[i], &tmp))
1395 if (unformat (input, #n)) { next_index = IP_LOOKUP_NEXT_##N; goto out;} 1408 *miss_next_indexp = next_index;
1412 #define foreach_acl_next \ 1418 u32 *next_indexp = va_arg (*args,
u32 *);
1425 for (i = 0; i <
vec_len (cm->unformat_acl_next_index_fns); i++)
1427 if (
unformat (input,
"%U", cm->unformat_acl_next_index_fns[i], &tmp))
1435 if (unformat (input, #n)) { next_index = ACL_NEXT_INDEX_##N; goto out;} 1444 else if (
unformat (input,
"%d", &tmp))
1453 *next_indexp = next_index;
1460 u32 *next_indexp = va_arg (*args,
u32 *);
1467 for (i = 0; i <
vec_len (cm->unformat_policer_next_index_fns); i++)
1470 (input,
"%U", cm->unformat_policer_next_index_fns[i], &tmp))
1486 *next_indexp = next_index;
1499 u32 table_index = ~0;
1500 u32 next_table_index = ~0;
1501 u32 miss_next_index = ~0;
1504 u32 current_data_flag = 0;
1505 int current_data_offset = 0;
1515 else if (
unformat (input,
"del-chain"))
1520 else if (
unformat (input,
"buckets %d", &nbuckets))
1522 else if (
unformat (input,
"skip %d", &skip))
1524 else if (
unformat (input,
"match %d", &match))
1526 else if (
unformat (input,
"table %d", &table_index))
1529 &mask, &skip, &match))
1531 else if (
unformat (input,
"memory-size %uM", &tmp))
1532 memory_size = tmp << 20;
1533 else if (
unformat (input,
"memory-size %uG", &tmp))
1534 memory_size = tmp << 30;
1535 else if (
unformat (input,
"next-table %d", &next_table_index))
1553 else if (
unformat (input,
"current-data-flag %d", ¤t_data_flag))
1556 if (
unformat (input,
"current-data-offset %d", ¤t_data_offset))
1563 if (is_add && mask == 0 && table_index == ~0)
1566 if (is_add && skip == ~0 && table_index == ~0)
1569 if (is_add && match == ~0 && table_index == ~0)
1572 if (!is_add && table_index == ~0)
1576 skip, match, next_table_index,
1577 miss_next_index, &table_index,
1578 current_data_flag, current_data_offset,
1594 .path =
"classify table",
1596 "classify table [miss-next|l2-miss_next|acl-miss-next <next_index>]" 1597 "\n mask <mask-value> buckets <nn> [skip <n>] [match <n>]" 1598 "\n [current-data-flag <n>] [current-data-offset <n>] [table <n>]" 1599 "\n [memory-size <nn>[M][G]] [next-table <n>]" 1600 "\n [del] [del-chain]",
1609 int verbose = va_arg (*args,
int);
1610 u32 index = va_arg (*args,
u32);
1615 s =
format (s,
"%10s%10s%10s%10s",
"TableIdx",
"Sessions",
"NextTbl",
1616 "NextNode", verbose ?
"Details" :
"");
1626 s =
format (s,
"\n nbuckets %d, skip %d match %d flag %d offset %d",
1648 u32 match_index = ~0;
1655 if (
unformat (input,
"index %d", &match_index))
1657 else if (
unformat (input,
"verbose %d", &verbose))
1659 else if (
unformat (input,
"verbose"))
1668 if (match_index == ~0 || (match_index == t - cm->tables))
1669 vec_add1 (indices, t - cm->tables);
1677 for (i = 0; i <
vec_len (indices); i++)
1679 verbose, indices[i]);
1691 .path =
"show classify tables",
1692 .short_help =
"show classify tables [index <nn>]",
1700 u8 **matchp = va_arg (*args,
u8 **);
1702 u8 *proto_header = 0;
1710 if (
unformat (input,
"src_port %d", &src_port))
1712 else if (
unformat (input,
"dst_port %d", &dst_port))
1718 h.
src_port = clib_host_to_net_u16 (src_port);
1719 h.
dst_port = clib_host_to_net_u16 (dst_port);
1721 memcpy (proto_header, &h,
sizeof (h));
1723 *matchp = proto_header;
1731 u8 **matchp = va_arg (*args,
u8 **);
1738 int src = 0, dst = 0;
1746 int fragment_id = 0;
1747 u32 fragment_id_val;
1755 if (
unformat (input,
"version %d", &version_val))
1757 else if (
unformat (input,
"hdr_length %d", &hdr_length_val))
1763 else if (
unformat (input,
"proto %d", &proto_val))
1765 else if (
unformat (input,
"tos %d", &tos_val))
1767 else if (
unformat (input,
"length %d", &length_val))
1769 else if (
unformat (input,
"fragment_id %d", &fragment_id_val))
1771 else if (
unformat (input,
"ttl %d", &ttl_val))
1773 else if (
unformat (input,
"checksum %d", &checksum_val))
1779 if (version + hdr_length + src + dst + proto + tos + length + fragment_id
1780 + ttl + checksum == 0)
1812 ip->
length = clib_host_to_net_u16 (length_val);
1818 ip->
checksum = clib_host_to_net_u16 (checksum_val);
1827 u8 **matchp = va_arg (*args,
u8 **);
1832 u8 traffic_class = 0;
1833 u32 traffic_class_val;
1836 int src = 0, dst = 0;
1840 int payload_length = 0;
1841 u32 payload_length_val;
1844 u32 ip_version_traffic_class_and_flow_label;
1848 if (
unformat (input,
"version %d", &version_val))
1850 else if (
unformat (input,
"traffic_class %d", &traffic_class_val))
1852 else if (
unformat (input,
"flow_label %d", &flow_label_val))
1858 else if (
unformat (input,
"proto %d", &proto_val))
1860 else if (
unformat (input,
"payload_length %d", &payload_length_val))
1862 else if (
unformat (input,
"hop_limit %d", &hop_limit_val))
1868 if (version + traffic_class + flow_label + src + dst + proto +
1869 payload_length + hop_limit == 0)
1888 ip_version_traffic_class_and_flow_label = 0;
1891 ip_version_traffic_class_and_flow_label |= (version_val & 0xF) << 28;
1894 ip_version_traffic_class_and_flow_label |=
1895 (traffic_class_val & 0xFF) << 20;
1898 ip_version_traffic_class_and_flow_label |= (flow_label_val & 0xFFFFF);
1901 clib_host_to_net_u32 (ip_version_traffic_class_and_flow_label);
1916 u8 **matchp = va_arg (*args,
u8 **);
1934 u8 *tagp = va_arg (*args,
u8 *);
1939 tagp[0] = (tag >> 8) & 0x0F;
1940 tagp[1] = tag & 0xFF;
1950 u8 **matchp = va_arg (*args,
u8 **);
1977 else if (
unformat (input,
"proto %U",
1984 else if (
unformat (input,
"ignore-tag1"))
1986 else if (
unformat (input,
"ignore-tag2"))
1988 else if (
unformat (input,
"cos1 %d", &cos1_val))
1990 else if (
unformat (input,
"cos2 %d", &cos2_val))
1995 if ((src + dst + proto + tag1 + tag2 +
1996 ignore_tag1 + ignore_tag2 + cos1 + cos2) == 0)
1999 if (tag1 || ignore_tag1 || cos1)
2001 if (tag2 || ignore_tag2 || cos2)
2015 match[19] = tag2_val[1];
2016 match[18] = tag2_val[0];
2018 match[18] |= (cos2_val & 0x7) << 5;
2021 match[21] = proto_val & 0xff;
2022 match[20] = proto_val >> 8;
2026 match[15] = tag1_val[1];
2027 match[14] = tag1_val[0];
2030 match[14] |= (cos1_val & 0x7) << 5;
2036 match[15] = tag1_val[1];
2037 match[14] = tag1_val[0];
2040 match[17] = proto_val & 0xff;
2041 match[16] = proto_val >> 8;
2044 match[14] |= (cos1_val & 0x7) << 5;
2050 match[18] |= (cos2_val & 0x7) << 5;
2052 match[14] |= (cos1_val & 0x7) << 5;
2055 match[13] = proto_val & 0xff;
2056 match[12] = proto_val >> 8;
2068 u8 **matchp = va_arg (*args,
u8 **);
2069 u32 table_index = va_arg (*args,
u32);
2104 if (match || l2 || l3 || l4)
2149 u8 action,
u32 metadata,
int is_add)
2152 vnet_classify_entry_5_t _max_e __attribute__ ((aligned (16)));
2153 vnet_classify_entry_t *e;
2157 return VNET_API_ERROR_NO_SUCH_TABLE;
2161 e = (vnet_classify_entry_t *) & _max_e;
2162 e->next_index = hit_next_index;
2163 e->opaque_index = opaque_index;
2164 e->advance = advance;
2178 e->metadata = metadata;
2188 e->key[i] &= t->
mask[i];
2195 return VNET_API_ERROR_NO_SUCH_ENTRY;
2206 u32 table_index = ~0;
2207 u32 hit_next_index = ~0;
2208 u64 opaque_index = ~0;
2235 else if (
unformat (input,
"policer-hit-next %U",
2238 else if (
unformat (input,
"opaque-index %lld", &opaque_index))
2241 cm, &match, table_index))
2243 else if (
unformat (input,
"advance %d", &advance))
2245 else if (
unformat (input,
"table-index %d", &table_index))
2247 else if (
unformat (input,
"action set-ip4-fib-id %d", &metadata))
2249 else if (
unformat (input,
"action set-ip6-fib-id %d", &metadata))
2251 else if (
unformat (input,
"action set-sr-policy-index %d", &metadata))
2256 for (i = 0; i <
vec_len (cm->unformat_opaque_index_fns); i++)
2258 if (
unformat (input,
"%U", cm->unformat_opaque_index_fns[i],
2268 if (table_index == ~0)
2271 if (is_add && match == 0)
2276 opaque_index, advance,
2277 action, metadata, is_add);
2286 "vnet_classify_add_del_session returned %d",
2295 .path =
"classify session",
2297 "classify session [hit-next|l2-hit-next|" 2298 "acl-hit-next <next_index>|policer-hit-next <policer_name>]" 2299 "\n table-index <nn> match [hex] [l2] [l3 ip4] [opaque-index <index>]" 2300 "\n [action set-ip4-fib-id|set-ip6-fib-id|set-sr-policy-index <n>] [del]",
2308 u64 *opaquep = va_arg (*args,
u64 *);
2314 *opaquep = sw_if_index;
2324 u32 *next_indexp = va_arg (*args,
u32 *);
2326 u32 next_index = ~0;
2329 cm->vlib_main, &node_index))
2335 cm->vlib_main, &node_index))
2343 *next_indexp = next_index;
2351 u32 *next_indexp = va_arg (*args,
u32 *);
2356 cm->vlib_main, &node_index))
2362 cm->vlib_main, &node_index))
2370 *next_indexp = next_index;
2378 u32 *next_indexp = va_arg (*args,
u32 *);
2383 cm->vlib_main, &node_index))
2388 *next_indexp = next_index;
2398 u32 *next_indexp = va_arg (*args,
u32 *);
2403 cm->vlib_main, &node_index))
2408 *next_indexp = next_index;
2482 classify_data_or_mask_t *mask, *data;
2485 u8 *mp = 0, *dp = 0;
2492 mask = (classify_data_or_mask_t *) mp;
2493 data = (classify_data_or_mask_t *) dp;
2496 memset (&mask->ip.src_address, 0xff, 4);
2498 tmp = clib_host_to_net_u32 (tm->
src.
as_u32);
2503 ep->
addr.
as_u32 = clib_host_to_net_u32 (tmp);
2518 vlib_cli_output (vm,
"Initialize: add %d (approx. half of %d sessions)...",
2521 for (i = 0; i < tm->
sessions / 2; i++)
2525 data->ip.src_address.as_u32 = ep->
addr.
as_u32;
2557 data->ip.src_address.as_u32 = ep->
addr.
as_u32;
2564 is_add ?
"add" :
"del",
2578 "%s[%d]: %U returned %d", is_add ?
"add" :
"del",
2591 vnet_classify_entry_t *e;
2597 data->ip.src_address.as_u32 = ep->
addr.
as_u32;
2602 (
u8 *) data, hash, 0 );
2605 clib_warning (
"Couldn't find %U index %d which should be present",
2610 key_minus_skip = (
u8 *) e->key;
2659 tm->
src.
as_u32 = clib_net_to_host_u32 (0x0100000A);
2661 tm->
seed = 0xDEADDABE;
2670 if (
unformat (input,
"sessions %d", &tmp))
2677 else if (
unformat (input,
"memory-size %uM", &tmp))
2679 else if (
unformat (input,
"memory-size %uG", &tmp))
2683 else if (
unformat (input,
"verbose"))
2688 else if (
unformat (input,
"churn-test"))
2709 .path =
"test classify",
2711 "test classify [src <ip>] [sessions <nn>] [buckets <nn>] [seed <nnn>]\n" 2712 " [memory-size <nn>[M|G]]\n" 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)
vnet_main_t * vnet_get_main(void)
classify_data_or_mask_t * mask
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)
static void vnet_classify_entry_claim_resource(vnet_classify_entry_t *e)
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
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
static clib_error_t * test_classify_churn(test_classify_main_t *tm)
void vnet_classify_register_unformat_acl_next_index_fn(unformat_function_t *fn)
struct _tcp_header tcp_header_t
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
u8 * format_mheap(u8 *s, va_list *va)
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)
vnet_classify_main_t * classify_main
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 vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
#define clib_error_return(e, args...)
#define foreach_ip4_proto_field
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)
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, u8 action, u32 metadata, int is_add)
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.
static test_classify_main_t test_classify_main
uword unformat_ip4_mask(unformat_input_t *input, va_list *args)
uword unformat_l2_input_next_index(unformat_input_t *input, va_list *args)
uword unformat_ip6_mask(unformat_input_t *input, va_list *args)
void vnet_classify_delete_table_index(vnet_classify_main_t *cm, u32 table_index, int del_chain)
#define pool_put(P, E)
Free an object E in pool P.
static vnet_classify_entry_t * split_and_rehash_linear(vnet_classify_table_t *t, vnet_classify_entry_t *old_values, u32 old_log2_pages, u32 new_log2_pages)
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 fib_table_unlock(u32 fib_index, fib_protocol_t proto, fib_source_t source)
Take a reference counting lock on the table.
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).
static vnet_classify_entry_t * split_and_rehash(vnet_classify_table_t *t, vnet_classify_entry_t *old_values, u32 old_log2_pages, u32 new_log2_pages)
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
Adjacency to drop this packet.
static uword unformat_acl_next_node(unformat_input_t *input, va_list *args)
static_always_inline uword vlib_get_thread_index(void)
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)
classify_data_or_mask_t * data
static void * clib_mem_set_heap(void *heap)
static uword unformat_ip_next_node(unformat_input_t *input, va_list *args)
static void vnet_classify_entry_free(vnet_classify_table_t *t, vnet_classify_entry_t *v, u32 log2_pages)
u8 * format_classify_table(u8 *s, va_list *args)
#define clib_warning(format, 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)
void fib_table_lock(u32 fib_index, fib_protocol_t proto, fib_source_t source)
Release a reference counting lock on the table.
#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)
static void clib_mem_free(void *p)
u32 fib_table_find_or_create_and_lock(fib_protocol_t proto, u32 table_id, fib_source_t src)
Get the index of the FIB for a Table-ID.
#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
static void vnet_classify_entry_release_resource(vnet_classify_entry_t *e)
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, u8 current_data_flag, i16 current_data_offset, int is_add, int del_chain)
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 * clib_mem_alloc_aligned(uword size, uword align)
static u32 random_u32(u32 *seed)
32-bit random number generator
#define foreach_l2_output_next
#define foreach_l2_input_next
int * working_copy_lengths
#define CLIB_MEMORY_BARRIER()
void vnet_classify_register_unformat_policer_next_index_fn(unformat_function_t *fn)
vlib_node_registration_t ip6_classify_node
(constructor) VLIB_REGISTER_NODE (ip6_classify_node)
#define foreach_tcp_proto_field
#define CLIB_CACHE_LINE_BYTES
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
vnet_classify_entry_t ** freelists
vnet_classify_entry_t * vnet_classify_find_entry(vnet_classify_table_t *t, u8 *h, u64 hash, f64 now)
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)
vnet_classify_table_t * table