29 __asm__
volatile (
"crc32l %[data], %[value];":[value]
"+r" (value):[data]
39 u64 tmp = ((
u64) data << 32) | (
u64) value;
92 else if (ip->
protocol == IP_PROTOCOL_ICMP)
94 icmp46_header_t *icmp = (
void *) (ip + 1);
95 if (icmp->type == ICMP4_echo_request || icmp->type == ICMP4_echo_reply)
97 return *((
u16 *) (icmp + 1));
99 else if (clib_net_to_host_u16 (ip->
length) >= 64)
108 else if (ip->
protocol == IP_PROTOCOL_ICMP)
110 icmp46_header_t *icmp = (
void *) (ip + 1);
111 if (icmp->type == ICMP4_echo_request ||
112 icmp->type == ICMP4_echo_reply)
114 return *((
u16 *) (icmp + 1));
130 if (
ip6_parse (ip6, buffer_len, &l4_protocol, &l4_offset, &frag_offset))
141 if (l4_protocol == IP_PROTOCOL_TCP || l4_protocol == IP_PROTOCOL_UDP)
148 else if (l4_protocol == IP_PROTOCOL_ICMP6)
150 icmp46_header_t *icmp = (icmp46_header_t *) (l4);
151 if (icmp->type == ICMP6_echo_request)
155 else if (icmp->type == ICMP6_echo_reply)
175 u8 suffix_len, suffix_shift;
185 if (ip6_src_len != 96)
187 clib_warning (
"MAP-T only supports ip6_src_len = 96 for now.");
193 if (ip6_src_len != 128)
196 (
"MAP-E requires a BR address, not a prefix (ip6_src_len should " 203 if (ip4_prefix_len + ea_bits_len < 32)
206 suffix_shift = 32 - ip4_prefix_len - ea_bits_len;
207 suffix_len = ea_bits_len;
212 suffix_len = 32 - ip4_prefix_len;
216 if (ea_bits_len > 0 && ((ip6_prefix_len + ea_bits_len) > 64 ||
217 ip6_prefix_len + suffix_len + psid_length > 64))
220 (
"Embedded Address bits must be within the first 64 bits of " 227 memset (d, 0,
sizeof (*d));
228 *map_domain_index = d - mm->
domains;
245 d->
psid_shift = 16 - psid_length - psid_offset;
250 if (d->
flags & MAP_DOMAIN_TRANSLATION)
310 if (d->
flags & MAP_DOMAIN_TRANSLATION)
358 clib_warning (
"MAP domain delete: domain does not exist: %d",
403 clib_warning (
"MAP rule: domain does not exist: %d", map_domain_index);
418 memset (d->
rules, 0, l);
423 clib_warning (
"MAP rule: PSID outside bounds: %d [%d]", psid,
430 d->
rules[psid] = *tep;
439 #ifdef MAP_SKIP_IP6_LOOKUP 476 else if (
unformat (line_input,
"on"))
501 else if (
unformat (line_input,
"on"))
519 u32 ip6_prefix_len = 0, ip4_prefix_len = 0, map_domain_index, ip6_src_len;
522 u32 ea_bits_len = 0, psid_offset = 0, psid_length = 0;
551 else if (
unformat (line_input,
"ea-bits-len %d", &ea_bits_len))
553 else if (
unformat (line_input,
"psid-offset %d", &psid_offset))
555 else if (
unformat (line_input,
"psid-len %d", &psid_length))
557 else if (
unformat (line_input,
"mtu %d", &mtu))
559 else if (
unformat (line_input,
"map-t"))
571 &ip6_prefix, ip6_prefix_len, &ip6_src, ip6_src_len,
572 ea_bits_len, psid_offset, psid_length, &map_domain_index,
584 u32 map_domain_index;
592 if (
unformat (line_input,
"index %d", &map_domain_index))
615 u32 psid = 0, map_domain_index;
623 if (
unformat (line_input,
"index %d", &map_domain_index))
625 else if (
unformat (line_input,
"psid %d", &psid))
646 #if MAP_SKIP_IP6_LOOKUP 657 memset (&ip4nh, 0,
sizeof (ip4nh));
658 memset (&ip6nh, 0,
sizeof (ip6nh));
730 else if (
unformat (line_input,
"off"))
760 else if (
unformat (line_input,
"outer"))
787 else if (
unformat (line_input,
"off"))
817 else if (
unformat (line_input,
"%x", &tc))
832 bool counters = va_arg (*args,
int);
837 memset (&ip6_prefix, 0,
sizeof (ip6_prefix));
842 "[%d] ip4-pfx %U/%d ip6-pfx %U/%d ip6-src %U/%d ea_bits_len %d psid-offset %d psid-len %d mtu %d %s",
889 f64 dt = (r->
ts + lifetime > now) ? (r->
ts + lifetime - now) : -1;
891 "ip4-reass src=%U dst=%U protocol=%d identifier=%d port=%d lifetime=%.3lf\n",
893 &k->dst.as_u8, k->protocol,
894 clib_net_to_host_u16 (k->fragment_id),
895 (r->
port >= 0) ? clib_net_to_host_u16 (r->
port) : -1, dt);
907 f64 dt = (r->
ts + lifetime > now) ? (r->
ts + lifetime - now) : -1;
909 "ip6-reass src=%U dst=%U protocol=%d identifier=%d lifetime=%.3lf\n",
911 &k->dst.as_u8, k->protocol,
912 clib_net_to_host_u32 (k->fragment_id), dt);
923 bool counters =
false;
924 u32 map_domain_index = ~0;
932 if (
unformat (line_input,
"counters"))
934 else if (
unformat (line_input,
"index %d", &map_domain_index))
945 if (map_domain_index == ~0)
948 pool_foreach(d, mm->
domains, ({vlib_cli_output(vm,
"%U", format_map_domain, d, counters);}));
994 ASSERT (ci < n->n_errors);
1006 int domains = 0, rules = 0, domaincount = 0, rulecount = 0;
1013 rulecount+= 0x1 << d->psid_length;
1014 rules += sizeof(ip6_address_t) * 0x1 << d->psid_length;
1016 domains +=
sizeof(*d);
1022 vlib_cli_output (vm,
"MAP domains: %d (%d bytes)\n", domaincount, domains);
1026 #if MAP_SKIP_IP6_LOOKUP 1028 "MAP pre-resolve: IP6 next-hop: %U (%u), IP4 next-hop: %U (%u)\n",
1039 "MAP IPv6 inbound security check: %s, fragmented packet security check: %s",
1040 mm->sec_check ?
"enabled" :
"disabled",
1041 mm->sec_check_frag ?
"enabled" :
"disabled");
1045 vlib_cli_output (vm,
"ICMP6 unreachables sent for unmatched packets: %s\n",
1046 mm->icmp6_enabled ?
"enabled" :
"disabled");
1048 mm->frag_inner ?
"enabled" :
"disabled");
1050 mm->frag_ignore_df ?
"enabled" :
"disabled");
1061 memset (total_pkts, 0,
sizeof (total_pkts));
1062 memset (total_bytes, 0,
sizeof (total_bytes));
1067 which = cm - mm->domain_counters;
1072 total_pkts[which] += v.
packets;
1073 total_bytes[which] += v.
bytes;
1080 total_bytes[MAP_DOMAIN_COUNTER_TX]);
1083 total_bytes[MAP_DOMAIN_COUNTER_RX]);
1099 u64 buffers = ~(0ull);
1100 u8 ip4 = 0, ip6 = 0;
1107 if (
unformat (line_input,
"lifetime %u", &lifetime))
1109 else if (
unformat (line_input,
"ht-ratio %lf", &ht_ratio))
1111 else if (
unformat (line_input,
"pool-size %u", &pool_size))
1113 else if (
unformat (line_input,
"buffers %llu", &buffers))
1115 else if (
unformat (line_input,
"ip4"))
1117 else if (
unformat (line_input,
"ip6"))
1166 u32 reass = 0, packets = 0;
1167 if (pool_size != ~0)
1176 "Setting ip4-reass pool-size (destroyed-reassembly=%u , dropped-fragments=%u)",
1189 "Setting ip4-reass ht-log2len (destroyed-reassembly=%u , dropped-fragments=%u)",
1200 if (buffers != ~(0ull))
1213 "Note: 'ip4-reass buffers' > pool-size * max-fragments-per-reassembly.");
1219 u32 reass = 0, packets = 0;
1220 if (pool_size != ~0)
1229 "Setting ip6-reass pool-size (destroyed-reassembly=%u , dropped-fragments=%u)",
1242 "Setting ip6-reass ht-log2len (destroyed-reassembly=%u , dropped-fragments=%u)",
1253 if (buffers != ~(0ull))
1266 "Note: 'ip6-reass buffers' > pool-size * max-fragments-per-reassembly.");
1287 format (s,
"MAP domain index: %d L4 port: %u", map_domain_index,
1288 clib_net_to_host_u16 (port));
1312 #define map_ip4_reass_pool_index(r) (r - map_main.ip4_reass_pool) 1359 u8 protocol,
u32 ** pi_to_drop)
1364 .dst.data_u32 = dst,
1365 .fragment_id = fragment_id,
1366 .protocol = protocol
1428 #ifdef MAP_IP4_REASS_COUNT_BYTES 1473 #define map_ip6_reass_pool_index(r) (r - map_main.ip6_reass_pool) 1529 u8 protocol,
u32 ** pi_to_drop)
1536 .fragment_id = fragment_id,
1537 .protocol = protocol
1542 for (i = 0; i < 10; i++)
1601 #ifdef MAP_IP6_REASS_COUNT_BYTES 1610 u16 data_offset,
u16 next_data_offset,
1611 u8 * data_start,
u16 data_len)
1614 u16 copied_len = (data_len > 20) ? 20 : data_len;
1636 else if (prev_f ==
NULL)
1641 if (!f || f->
pi != ~0)
1649 clib_memcpy (prev_f->next_data, data_start, copied_len);
1650 prev_f->next_data_len = copied_len;
1651 prev_f->next_data_offset = data_offset;
1655 if (((
ip4_header_t *) data_start)->ip_version_and_header_length != 0x45)
1677 if (dropped_packets)
1712 u32 desired_size = (
u32) (pool_size * ht_ratio);
1714 for (i = 1; i < 31; i++)
1715 if ((1 << i) >= desired_size)
1722 u32 * dropped_packets)
1739 u32 * dropped_packets)
1770 if (dropped_packets)
1805 u32 * dropped_packets)
1822 u32 * dropped_packets)
1859 .path =
"map params reassembly",
1860 .short_help =
"map params reassembly [ip4 | ip6] [lifetime <lifetime-ms>] " 1861 "[pool-size <pool-size>] [buffers <buffers>] " 1862 "[ht-ratio <ht-ratio>]",
1879 .path =
"map params traffic-class",
1880 .short_help =
"map params traffic-class {0x0-0xff | copy}",
1897 .path =
"map params pre-resolve",
1898 .short_help =
" map params pre-resolve {ip4-nh <address>} " 1899 "| {ip6-nh <address>}",
1915 .path =
"map params security-check",
1916 .short_help =
"map params security-check on|off",
1932 .path =
"map params icmp source-address",
1933 .short_help =
"map params icmp source-address <ip4-address>",
1948 .path =
"map params icmp6 unreachables",
1949 .short_help =
"map params icmp6 unreachables {on|off}",
1961 .path =
"map params fragment",
1962 .short_help =
"map params fragment inner|outer",
1980 .path =
"map params fragment ignore-df",
1981 .short_help =
"map params fragment ignore-df on|off",
1998 .path =
"map params security-check fragments",
1999 .short_help =
"map params security-check fragments on|off",
2011 .path =
"map add domain",
2012 .short_help =
"map add domain ip4-pfx <ip4-pfx> ip6-pfx <ip6-pfx> " 2013 "ip6-src <ip6-pfx> ea-bits-len <n> psid-offset <n> psid-len <n> " 2014 "[map-t] [mtu <mtu>]",
2026 .path =
"map add rule",
2027 .short_help =
"map add rule index <domain> psid <psid> ip6-dst <ip6-addr>",
2039 .path =
"map del domain",
2040 .short_help =
"map del domain index <domain>",
2052 .path =
"show map domain",
2053 .short_help =
"show map domain index <n> [counters]",
2065 .path =
"show map stats",
2066 .short_help =
"show map stats",
2078 .path =
"show map fragments",
2079 .short_help =
"show map fragments",
2094 #ifdef MAP_SKIP_IP6_LOOKUP static map_dpo_t * map_dpo_get(index_t index)
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
fib_protocol_t fp_proto
protocol type
#define map_ip4_reass_lock()
map_ip4_reass_t * ip4_reass_pool
u64 packets
packet counter
u32 ip4_reass_conf_buffers
sll srl srl sll sra u16x4 i
static clib_error_t * map_fragment_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
#define MAP_IP6_REASS_CONF_BUFFERS_MAX
int map_delete_domain(u32 map_domain_index)
#define MAP_IP6_REASS_BUFFERS_DEFAULT
void vlib_validate_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
validate a combined counter
fib_node_index_t fib_table_lookup_exact_match(u32 fib_index, const fib_prefix_t *prefix)
Perfom an exact match in the non-forwarding table.
volatile u32 * ip6_reass_lock
static vlib_main_t * vlib_get_main(void)
u32 fragments[MAP_IP4_REASS_MAX_FRAGMENTS_PER_REASSEMBLY]
#define MAP_IP6_REASS_LIFETIME_DEFAULT
static_always_inline map_ip6_reass_t * map_ip6_reass_lookup(map_ip6_reass_key_t *k, u32 bucket, f64 now)
#define pool_alloc(P, N)
Allocate N more free elements to pool (unspecified alignment).
vlib_counter_t * maxi
Shared wide counter pairs.
static u8 * format_map_domain(u8 *s, va_list *args)
static f64 vlib_time_now(vlib_main_t *vm)
static clib_error_t * show_map_domain_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
void map_ip4_reass_reinit(u32 *trashed_reass, u32 *dropped_packets)
static clib_error_t * map_security_check_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
u64 map_error_counter_get(u32 node_index, map_error_t map_error)
static_always_inline int ip6_parse(const ip6_header_t *ip6, u32 buff_len, u8 *l4_protocol, u16 *l4_offset, u16 *frag_hdr_offset)
static clib_error_t * map_fragment_df_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
static clib_error_t * show_map_fragments_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
i32 ip6_get_port(ip6_header_t *ip6, map_dir_e dir, u16 buffer_len)
void dpo_copy(dpo_id_t *dst, const dpo_id_t *src)
atomic copy a data-plane object.
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
static void map_domain_counter_unlock(map_main_t *mm)
Combined counter to hold both packets and byte differences.
static u64 clib_xxhash(u64 key)
static heap_elt_t * last(heap_header_t *h)
u32 ip4_reass_buffered_counter
static u8 * format_map_ip4_reass(u8 *s, va_list *args)
ip6_address_t preresolve_ip6
static u32 crc_u32(u32 data, u32 value)
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
int map_ip6_reass_conf_ht_ratio(f32 ht_ratio, u32 *trashed_reass, u32 *dropped_packets)
#define MAP_IP6_REASS_CONF_LIFETIME_MAX
map_ip6_reass_t * ip6_reass_pool
map_ip6_fragment_t fragments[MAP_IP6_REASS_MAX_FRAGMENTS_PER_REASSEMBLY]
ip4_address_t preresolve_ip4
#define map_ip6_reass_unlock()
void map_dpo_create(dpo_proto_t dproto, u32 domain_index, dpo_id_t *dpo)
vnet_main_t * vnet_get_main(void)
#define MAP_IP4_REASS_MAX_FRAGMENTS_PER_REASSEMBLY
#define static_always_inline
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
static clib_error_t * map_pre_resolve_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
#define MAP_REASS_INDEX_NONE
#define VLIB_INIT_FUNCTION(x)
static clib_error_t * map_icmp_unreachables_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
void fib_table_entry_special_remove(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source)
Remove a 'special' entry from the FIB.
vlib_combined_counter_main_t * domain_counters
static int ip4_get_fragment_offset(ip4_header_t *i)
ip4_address_t icmp4_src_address
static clib_error_t * map_add_domain_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Aggregrate type for a prefix.
vlib_simple_counter_main_t icmp_relayed
int map_ip4_reass_add_fragment(map_ip4_reass_t *r, u32 pi)
#define clib_warning(format, args...)
u8 map_get_ht_log2len(f32 ht_ratio, u16 pool_size)
#define vec_resize(V, N)
Resize a vector (no header, unspecified alignment) Add N elements to end of given vector V...
#define MAP_IP4_REASS_CONF_LIFETIME_MAX
static_always_inline map_ip4_reass_t * map_ip4_reass_lookup(map_ip4_reass_key_t *k, u32 bucket, f64 now)
int map_add_del_psid(u32 map_domain_index, u16 psid, ip6_address_t *tep, u8 is_add)
const int fib_entry_get_dpo_for_source(fib_node_index_t fib_entry_index, fib_source_t source, dpo_id_t *dpo)
#define MAP_IP6_REASS_CONF_POOL_SIZE_MAX
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
static void vlib_zero_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
Clear a combined counter Clears the set of per-thread u16 counters, and the shared vlib_counter_t...
int map_ip6_reass_conf_buffers(u32 buffers)
#define map_ip4_reass_pool_index(r)
static clib_error_t * map_add_rule_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
int map_ip4_reass_conf_lifetime(u16 lifetime_ms)
vlib_error_main_t error_main
static u32 vlib_error_get_code(vlib_error_t e)
dpo_type_t dpoi_type
the type
#define MAP_IP4_REASS_BUFFERS_DEFAULT
#define MAP_IP4_REASS_CONF_HT_RATIO_MAX
static u8 * format_map_ip6_reass(u8 *s, va_list *args)
volatile u32 * ip4_reass_lock
u16 ip4_reass_conf_pool_size
load-balancing over a choice of [un]equal cost paths
int map_ip4_reass_conf_buffers(u32 buffers)
#define pool_put(P, E)
Free an object E in pool P.
void map_t_dpo_create(dpo_proto_t dproto, u32 domain_index, dpo_id_t *dpo)
void map_dpo_module_init(void)
int map_ip6_reass_conf_lifetime(u16 lifetime_ms)
map_ip4_reass_t * map_ip4_reass_get(u32 src, u32 dst, u16 fragment_id, u8 protocol, u32 **pi_to_drop)
static void vlib_get_combined_counter(vlib_combined_counter_main_t *cm, u32 index, vlib_counter_t *result)
Get the value of a combined counter, never called in the speed path Scrapes the entire set of mini co...
int map_ip4_reass_conf_pool_size(u16 pool_size, u32 *trashed_reass, u32 *dropped_packets)
u16 * ip6_reass_hash_table
u16 * ip4_reass_hash_table
i32 ip4_get_port(ip4_header_t *ip, map_dir_e dir, u16 buffer_len)
#define MAP_IP4_REASS_HT_RATIO_DEFAULT
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
const dpo_id_t * load_balance_get_bucket(index_t lbi, u32 bucket)
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P (general version).
void map_ip4_drop_pi(u32 pi)
u32 ip6_fib_table_fwding_lookup(ip6_main_t *im, u32 fib_index, const ip6_address_t *dst)
#define pool_free(p)
Free a pool.
void map_ip4_reass_free(map_ip4_reass_t *r, u32 **pi_to_drop)
static clib_error_t * map_params_reass_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
u16 ip6_reass_conf_pool_size
static_always_inline void map_ip4_reass_get_fragments(map_ip4_reass_t *r, u32 **pi)
map_ip6_reass_t * map_ip6_reass_get(ip6_address_t *src, ip6_address_t *dst, u32 fragment_id, u8 protocol, u32 **pi_to_drop)
#define MAP_IP6_REASS_POOL_SIZE_DEFAULT
#define vec_free(V)
Free vector's memory (no header).
int map_create_domain(ip4_address_t *ip4_prefix, u8 ip4_prefix_len, ip6_address_t *ip6_prefix, u8 ip6_prefix_len, ip6_address_t *ip6_src, u8 ip6_src_len, u8 ea_bits_len, u8 psid_offset, u8 psid_length, u32 *map_domain_index, u16 mtu, u8 flags)
static clib_error_t * map_icmp_relay_source_address_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
static vlib_node_runtime_t * vlib_node_get_runtime(vlib_main_t *vm, u32 node_index)
Get node runtime by node index.
#define clib_memcpy(a, b, c)
u32 fib_node_index_t
A typedef of a node index.
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
int map_ip4_reass_conf_ht_ratio(f32 ht_ratio, u32 *trashed_reass, u32 *dropped_packets)
static clib_error_t * map_del_domain_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
static void map_domain_counter_lock(map_main_t *mm)
f32 ip4_reass_conf_ht_ratio
#define VLIB_CLI_COMMAND(x,...)
A representation of a MAP DPO.
fib_node_index_t fib_table_entry_special_dpo_add(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags, const dpo_id_t *dpo)
Add a 'special' entry to the FIB that links to the DPO passed A special entry is an entry that the FI...
void vlib_validate_simple_counter(vlib_simple_counter_main_t *cm, u32 index)
validate a simple counter
#define ip6_frag_hdr_offset(hdr)
int map_ip6_reass_conf_pool_size(u16 pool_size, u32 *trashed_reass, u32 *dropped_packets)
#define u8_ptr_add(ptr, index)
void map_ip6_reass_reinit(u32 *trashed_reass, u32 *dropped_packets)
static void clib_mem_free(void *p)
#define map_ip4_reass_unlock()
static void vlib_zero_simple_counter(vlib_simple_counter_main_t *cm, u32 index)
Clear a simple counter Clears the set of per-thread u16 counters, and the u64 counter.
u8 * format_map_trace(u8 *s, va_list *args)
#define MAP_IP6_REASS_HT_RATIO_DEFAULT
f32 ip6_reass_conf_ht_ratio
static clib_error_t * map_traffic_class_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
index_t dpoi_index
the index of objects of that type
#define FIB_NODE_INDEX_INVALID
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u16 ip6_reass_conf_lifetime_ms
#define map_ip6_reass_lock()
#define MAP_IP4_REASS_POOL_SIZE_DEFAULT
#define MAP_IP6_REASS_CONF_HT_RATIO_MAX
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
char * name
The counter collection's name.
A collection of combined counters.
#define MAP_IP4_REASS_LIFETIME_DEFAULT
IP4 reassembly logic: One virtually reassembled flow requires a map_ip4_reass_t structure in order to...
#define MAP_IP4_REASS_CONF_POOL_SIZE_MAX
static u64 vlib_get_simple_counter(vlib_simple_counter_main_t *cm, u32 index)
Get the value of a simple counter Scrapes the entire set of mini counters.
void map_ip6_reass_free(map_ip6_reass_t *r, u32 **pi_to_drop)
vlib_simple_counter_main_t * simple_domain_counters
static void * clib_mem_alloc_aligned(uword size, uword align)
#define MAP_IP6_REASS_MAX_FRAGMENTS_PER_REASSEMBLY
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
u16 ip4_reass_conf_lifetime_ms
#define vec_foreach(var, vec)
Vector iterator.
index_t ip4_fib_table_lookup_lb(ip4_fib_t *fib, const ip4_address_t *addr)
static clib_error_t * map_security_check_frag_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
#define MAP_IP4_REASS_CONF_BUFFERS_MAX
#define clib_error_return(e, args...)
u32 ip6_reass_buffered_counter
#define CLIB_CACHE_LINE_BYTES
int map_ip6_reass_add_fragment(map_ip6_reass_t *r, u32 pi, u16 data_offset, u16 next_data_offset, u8 *data_start, u16 data_len)
static void map_pre_resolve(ip4_address_t *ip4, ip6_address_t *ip6)
clib_error_t * map_init(vlib_main_t *vm)
static clib_error_t * show_map_stats_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
void map_ip6_drop_pi(u32 pi)
#define map_ip6_reass_pool_index(r)
u32 ip6_reass_conf_buffers
u32 md_domain
the MAP domain index
static uword pool_elts(void *v)
Number of active elements in a pool.