FD.io VPP  v16.09
Vector Packet Processing
map.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <stdbool.h>
16 #include <vppinfra/error.h>
17 #include <vnet/vnet.h>
18 #include <vnet/ip/ip.h>
19 #include <vlib/vlib.h>
20 
21 #define MAP_SKIP_IP6_LOOKUP 1
22 
23 typedef enum
24 {
27 } map_dir_e;
28 
29 int map_create_domain (ip4_address_t * ip4_prefix, u8 ip4_prefix_len,
30  ip6_address_t * ip6_prefix, u8 ip6_prefix_len,
31  ip6_address_t * ip6_src, u8 ip6_src_len,
32  u8 ea_bits_len, u8 psid_offset, u8 psid_length,
33  u32 * map_domain_index, u16 mtu, u8 flags);
34 int map_delete_domain (u32 map_domain_index);
35 int map_add_del_psid (u32 map_domain_index, u16 psid, ip6_address_t * tep,
36  u8 is_add);
37 u8 *format_map_trace (u8 * s, va_list * args);
38 i32 ip4_get_port (ip4_header_t * ip, map_dir_e dir, u16 buffer_len);
39 i32 ip6_get_port (ip6_header_t * ip6, map_dir_e dir, u16 buffer_len);
40 u16 ip4_map_get_port (ip4_header_t * ip, map_dir_e dir);
41 
42 typedef enum __attribute__ ((__packed__))
43 {
44  MAP_DOMAIN_PREFIX = 1 << 0, MAP_DOMAIN_TRANSLATION = 1 << 1, // The domain uses MAP-T
46 
47 /**
48  * IP4 reassembly logic:
49  * One virtually reassembled flow requires a map_ip4_reass_t structure in order
50  * to keep the first-fragment port number and, optionally, cache out of sequence
51  * packets.
52  * There are up to MAP_IP4_REASS_MAX_REASSEMBLY such structures.
53  * When in use, those structures are stored in a hash table of MAP_IP4_REASS_BUCKETS buckets.
54  * When a new structure needs to be used, it is allocated from available ones.
55  * If there is no structure available, the oldest in use is selected and used if and
56  * only if it was first allocated more than MAP_IP4_REASS_LIFETIME seconds ago.
57  * In case no structure can be allocated, the fragment is dropped.
58  */
59 
60 #define MAP_IP4_REASS_LIFETIME_DEFAULT (100) /* ms */
61 #define MAP_IP4_REASS_HT_RATIO_DEFAULT (1.0)
62 #define MAP_IP4_REASS_POOL_SIZE_DEFAULT 1024 // Number of reassembly structures
63 #define MAP_IP4_REASS_BUFFERS_DEFAULT 2048
64 
65 #define MAP_IP4_REASS_MAX_FRAGMENTS_PER_REASSEMBLY 5 // Number of fragment per reassembly
66 
67 #define MAP_IP6_REASS_LIFETIME_DEFAULT (100) /* ms */
68 #define MAP_IP6_REASS_HT_RATIO_DEFAULT (1.0)
69 #define MAP_IP6_REASS_POOL_SIZE_DEFAULT 1024 // Number of reassembly structures
70 #define MAP_IP6_REASS_BUFFERS_DEFAULT 2048
71 
72 #define MAP_IP6_REASS_MAX_FRAGMENTS_PER_REASSEMBLY 5
73 
74 #define MAP_IP6_REASS_COUNT_BYTES
75 #define MAP_IP4_REASS_COUNT_BYTES
76 
77 //#define IP6_MAP_T_OVERRIDE_TOS 0
78 
79 /*
80  * This structure _MUST_ be no larger than a single cache line (64 bytes).
81  * If more space is needed make a union of ip6_prefix and *rules, those are mutually exclusive.
82  */
83 typedef struct
84 {
98 
99  /* helpers */
103 
104  /* not used by forwarding */
106 } map_domain_t;
107 
108 #define MAP_REASS_INDEX_NONE ((u16)0xffff)
109 
110 /*
111  * Hash key, padded out to 16 bytes for fast compare
112  */
113 /* *INDENT-OFF* */
114 typedef union {
115  CLIB_PACKED (struct {
116  ip4_address_t src;
117  ip4_address_t dst;
118  u16 fragment_id;
119  u8 protocol;
120  });
122  u32 as_u32[4];
124 /* *INDENT-ON* */
125 
126 typedef struct
127 {
130 #ifdef MAP_IP4_REASS_COUNT_BYTES
133 #endif
141 
142 /*
143  * MAP domain counters
144  */
145 typedef enum
146 {
147  /* Simple counters */
149  /* Combined counters */
154 
155 /*
156  * main_main_t
157  */
158 /* *INDENT-OFF* */
159 typedef union {
160  CLIB_PACKED (struct {
161  ip6_address_t src;
162  ip6_address_t dst;
163  u32 fragment_id;
164  u8 protocol;
165  });
167  u32 as_u32[10];
169 /* *INDENT-OFF* */
170 
171 typedef struct {
172  u32 pi; //Cached packet or ~0
173  u16 next_data_offset; //The data offset of the additional 20 bytes or ~0
174  u8 next_data_len; //Number of bytes ready to be copied (20 if not last fragment)
175  u8 next_data[20]; //The 20 additional bytes
177 
178 typedef struct {
181 #ifdef MAP_IP6_REASS_COUNT_BYTES
184 #endif
185  u16 bucket; //What hash bucket this element is linked in
192 
193 typedef struct {
194  /* pool of MAP domains */
196 
197  /* MAP Domain packet/byte counters indexed by map domain index */
200  volatile u32 *counter_lock;
201 
202 #ifdef MAP_SKIP_IP6_LOOKUP
203  /* pre-presolve */
204  u32 adj6_index, adj4_index;
207 #endif
208 
209  /* Traffic class: zero, copy (~0) or fixed value */
211  bool tc_copy;
212 
213  bool sec_check; /* Inbound security check */
214  bool sec_check_frag; /* Inbound security check for (subsequent) fragments */
215  bool icmp6_enabled; /* Send destination unreachable for security check failure */
216 
217  /* ICMPv6 -> ICMPv4 relay parameters */
220 
221  /* convenience */
224 
225  /*
226  * IPv4 encap and decap reassembly
227  */
228  /* Configuration */
229  f32 ip4_reass_conf_ht_ratio; //Size of ht is 2^ceil(log2(ratio*pool_size))
230  u16 ip4_reass_conf_pool_size; //Max number of allocated reass structures
231  u16 ip4_reass_conf_lifetime_ms; //Time a reassembly struct is considered valid in ms
232  u32 ip4_reass_conf_buffers; //Maximum number of buffers used by ip4 reassembly
233 
234  /* Runtime */
236  u8 ip4_reass_ht_log2len; //Hash table size is 2^log2len
240  volatile u32 *ip4_reass_lock;
241 
242  /* Counters */
244 
245  bool frag_inner; /* Inner or outer fragmentation */
246  bool frag_ignore_df; /* Fragment (outer) packet even if DF is set */
247 
248  /*
249  * IPv6 decap reassembly
250  */
251  /* Configuration */
252  f32 ip6_reass_conf_ht_ratio; //Size of ht is 2^ceil(log2(ratio*pool_size))
253  u16 ip6_reass_conf_pool_size; //Max number of allocated reass structures
254  u16 ip6_reass_conf_lifetime_ms; //Time a reassembly struct is considered valid in ms
255  u32 ip6_reass_conf_buffers; //Maximum number of buffers used by ip6 reassembly
256 
257  /* Runtime */
259  u8 ip6_reass_ht_log2len; //Hash table size is 2^log2len
263  volatile u32 *ip6_reass_lock;
264 
265  /* Counters */
267 
268 } map_main_t;
269 
270 /*
271  * MAP Error counters/messages
272  */
273 #define foreach_map_error \
274  /* Must be first. */ \
275  _(NONE, "valid MAP packets") \
276  _(BAD_PROTOCOL, "bad protocol") \
277  _(SEC_CHECK, "security check failed") \
278  _(ENCAP_SEC_CHECK, "encap security check failed") \
279  _(DECAP_SEC_CHECK, "decap security check failed") \
280  _(ICMP, "unable to translate ICMP") \
281  _(ICMP_RELAY, "unable to relay ICMP") \
282  _(UNKNOWN, "unknown") \
283  _(NO_BINDING, "no binding") \
284  _(NO_DOMAIN, "no domain") \
285  _(FRAGMENTED, "packet is a fragment") \
286  _(FRAGMENT_MEMORY, "could not cache fragment") \
287  _(FRAGMENT_MALFORMED, "fragment has unexpected format")\
288  _(FRAGMENT_DROPPED, "dropped cached fragment") \
289  _(MALFORMED, "malformed packet") \
290  _(DF_SET, "can't fragment, DF set")
291 
292 typedef enum {
293 #define _(sym,str) MAP_ERROR_##sym,
295 #undef _
297  } map_error_t;
298 
299 u64 map_error_counter_get(u32 node_index, map_error_t map_error);
300 
301 typedef struct {
304 } map_trace_t;
305 
307 
310 
315 
320 
321 /*
322  * map_get_pfx
323  */
326 {
327  u16 psid = (port >> d->psid_shift) & d->psid_mask;
328 
329  if (d->ea_bits_len == 0 && d->rules)
330  return clib_net_to_host_u64(d->rules[psid].as_u64[0]);
331 
332  u32 suffix = (addr >> d->suffix_shift) & d->suffix_mask;
333  u64 ea = d->ea_bits_len == 0 ? 0 : (((u64) suffix << d->psid_length)) | psid;
334 
335  return clib_net_to_host_u64(d->ip6_prefix.as_u64[0]) | ea << d->ea_shift;
336 }
337 
340 {
341  return clib_host_to_net_u64(map_get_pfx(d, clib_net_to_host_u32(addr),
342  clib_net_to_host_u16(port)));
343 }
344 
345 /*
346  * map_get_sfx
347  */
350 {
351  u16 psid = (port >> d->psid_shift) & d->psid_mask;
352 
353  /* Shared 1:1 mode. */
354  if (d->ea_bits_len == 0 && d->rules)
355  return clib_net_to_host_u64(d->rules[psid].as_u64[1]);
356  if (d->ip6_prefix_len == 128)
357  return clib_net_to_host_u64(d->ip6_prefix.as_u64[1]);
358 
359  /* IPv4 prefix */
360  if (d->flags & MAP_DOMAIN_PREFIX)
361  return (u64) (addr & ~d->suffix_mask) << 16;
362 
363  /* Shared or full IPv4 address */
364  return ((u64) addr << 16) | psid;
365 }
366 
369 {
370  return clib_host_to_net_u64(map_get_sfx(d, clib_net_to_host_u32(addr),
371  clib_net_to_host_u16(port)));
372 }
373 
376 {
377  return clib_host_to_net_u32(clib_net_to_host_u64(addr->as_u64[1]) >> 16);
378 }
379 
380 /*
381  * Get the MAP domain from an IPv4 lookup adjacency.
382  */
384 ip4_map_get_domain (u32 adj_index, u32 *map_domain_index)
385 {
386  map_main_t *mm = &map_main;
388  ip_adjacency_t *adj = ip_get_adjacency(lm, adj_index);
389  ASSERT(adj);
390  uword *p = (uword *)adj->rewrite_data;
391  ASSERT(p);
392  *map_domain_index = p[0];
393  return pool_elt_at_index(mm->domains, p[0]);
394 }
395 
396 /*
397  * Get the MAP domain from an IPv6 lookup adjacency.
398  * If the IPv6 address or prefix is not shared, no lookup is required.
399  * The IPv4 address is used otherwise.
400  */
403  u32 *map_domain_index, u8 *error)
404 {
405  map_main_t *mm = &map_main;
406  ip4_main_t *im4 = &ip4_main;
408 
409  /*
410  * Disable direct MAP domain lookup on decap, until the security check is updated to verify IPv4 SA.
411  * (That's done implicitly when MAP domain is looked up in the IPv4 FIB)
412  */
413 #ifdef MAP_NONSHARED_DOMAIN_ENABLED
415  ip_adjacency_t *adj = ip_get_adjacency(lm6, adj_index);
416  ASSERT(adj);
417  uword *p = (uword *)adj->rewrite_data;
418  ASSERT(p);
419  *map_domain_index = p[0];
420  if (p[0] != ~0)
421  return pool_elt_at_index(mm->domains, p[0]);
422 #endif
423 
424  u32 ai = ip4_fib_lookup_with_table(im4, 0, addr, 0);
425  ip_adjacency_t *adj4 = ip_get_adjacency (lm4, ai);
428  uword *p = (uword *)adj4->rewrite_data;
429  *map_domain_index = p[0];
430  return pool_elt_at_index(mm->domains, *map_domain_index);
431  }
432  *error = MAP_ERROR_NO_DOMAIN;
433  return NULL;
434 }
435 
437 map_ip4_reass_get(u32 src, u32 dst, u16 fragment_id,
438  u8 protocol, u32 **pi_to_drop);
439 void
440 map_ip4_reass_free(map_ip4_reass_t *r, u32 **pi_to_drop);
441 
442 #define map_ip4_reass_lock() while (__sync_lock_test_and_set(map_main.ip4_reass_lock, 1)) {}
443 #define map_ip4_reass_unlock() do {CLIB_MEMORY_BARRIER(); *map_main.ip4_reass_lock = 0;} while(0)
444 
447 {
448  int i;
450  if(r->fragments[i] != ~0) {
451  vec_add1(*pi, r->fragments[i]);
452  r->fragments[i] = ~0;
453  map_main.ip4_reass_buffered_counter--;
454  }
455 }
456 
458 
460 map_ip6_reass_get(ip6_address_t *src, ip6_address_t *dst, u32 fragment_id,
461  u8 protocol, u32 **pi_to_drop);
462 void
463 map_ip6_reass_free(map_ip6_reass_t *r, u32 **pi_to_drop);
464 
465 #define map_ip6_reass_lock() while (__sync_lock_test_and_set(map_main.ip6_reass_lock, 1)) {}
466 #define map_ip6_reass_unlock() do {CLIB_MEMORY_BARRIER(); *map_main.ip6_reass_lock = 0;} while(0)
467 
468 int
470  u16 data_offset, u16 next_data_offset,
471  u8 *data_start, u16 data_len);
472 
473 void map_ip4_drop_pi(u32 pi);
474 
475 int map_ip4_reass_conf_ht_ratio(f32 ht_ratio, u32 *trashed_reass, u32 *dropped_packets);
476 #define MAP_IP4_REASS_CONF_HT_RATIO_MAX 100
477 int map_ip4_reass_conf_pool_size(u16 pool_size, u32 *trashed_reass, u32 *dropped_packets);
478 #define MAP_IP4_REASS_CONF_POOL_SIZE_MAX (0xfeff)
479 int map_ip4_reass_conf_lifetime(u16 lifetime_ms);
480 #define MAP_IP4_REASS_CONF_LIFETIME_MAX 0xffff
481 int map_ip4_reass_conf_buffers(u32 buffers);
482 #define MAP_IP4_REASS_CONF_BUFFERS_MAX (0xffffffff)
483 
484 void map_ip6_drop_pi(u32 pi);
485 
486 
487 int map_ip6_reass_conf_ht_ratio(f32 ht_ratio, u32 *trashed_reass, u32 *dropped_packets);
488 #define MAP_IP6_REASS_CONF_HT_RATIO_MAX 100
489 int map_ip6_reass_conf_pool_size(u16 pool_size, u32 *trashed_reass, u32 *dropped_packets);
490 #define MAP_IP6_REASS_CONF_POOL_SIZE_MAX (0xfeff)
491 int map_ip6_reass_conf_lifetime(u16 lifetime_ms);
492 #define MAP_IP6_REASS_CONF_LIFETIME_MAX 0xffff
493 int map_ip6_reass_conf_buffers(u32 buffers);
494 #define MAP_IP6_REASS_CONF_BUFFERS_MAX (0xffffffff)
495 
497 int ip6_parse(const ip6_header_t *ip6, u32 buff_len,
498  u8 *l4_protocol, u16 *l4_offset, u16 *frag_hdr_offset)
499 {
500  if (ip6->protocol == IP_PROTOCOL_IPV6_FRAGMENTATION) {
501  *l4_protocol = ((ip6_frag_hdr_t *)(ip6 + 1))->next_hdr;
502  *frag_hdr_offset = sizeof(*ip6);
503  *l4_offset = sizeof(*ip6) + sizeof(ip6_frag_hdr_t);
504  } else {
505  *l4_protocol = ip6->protocol;
506  *frag_hdr_offset = 0;
507  *l4_offset = sizeof(*ip6);
508  }
509 
510  return (buff_len < (*l4_offset + 4)) ||
511  (clib_net_to_host_u16(ip6->payload_length) < (*l4_offset + 4 - sizeof(*ip6)));
512 }
513 
514 
515 #define u8_ptr_add(ptr, index) (((u8 *)ptr) + index)
516 #define u16_net_add(u, val) clib_host_to_net_u16(clib_net_to_host_u16(u) + (val))
517 
518 #define frag_id_6to4(id) ((id) ^ ((id) >> 16))
519 
522  ip6_address_t *ip6, const ip4_address_t *ip4)
523 {
524  ASSERT(d->ip6_src_len == 96); //No support for other lengths for now
525  ip6->as_u64[0] = d->ip6_src.as_u64[0];
526  ip6->as_u32[2] = d->ip6_src.as_u32[2];
527  ip6->as_u32[3] = ip4->as_u32;
528 }
529 
532 {
533  ASSERT(d->ip6_src_len == 96); //No support for other lengths for now
534  return addr->as_u32[3];
535 }
536 
537 static inline void
539 {
540  if (mm->counter_lock)
541  while (__sync_lock_test_and_set(mm->counter_lock, 1))
542  /* zzzz */ ;
543 }
544 static inline void
546 {
547  if (mm->counter_lock)
548  *mm->counter_lock = 0;
549 }
550 
551 
554  vlib_node_runtime_t *node, vlib_error_t *error,
555  u32 next)
556 {
557  u32 n_left_from, *from, next_index, *to_next, n_left_to_next;
558  //Deal with fragments that are ready
559  from = pi_vector;
560  n_left_from = vec_len(pi_vector);
561  next_index = node->cached_next_index;
562  while (n_left_from > 0) {
563  vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
564  while (n_left_from > 0 && n_left_to_next > 0) {
565  u32 pi0 = to_next[0] = from[0];
566  from += 1;
567  n_left_from -= 1;
568  to_next += 1;
569  n_left_to_next -= 1;
570  vlib_buffer_t *p0 = vlib_get_buffer(vm, pi0);
571  p0->error = *error;
572  vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, pi0, next);
573  }
574  vlib_put_next_frame(vm, node, next_index, n_left_to_next);
575  }
576 }
577 
578 /*
579  * fd.io coding-style-patch-verification: ON
580  *
581  * Local Variables:
582  * eval: (c-set-style "gnu")
583  * End:
584  */
u16 forwarded
Definition: map.h:183
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)
Definition: map.c:1522
void vlib_put_next_frame(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, u32 n_vectors_left)
Release pointer to next frame vector data.
Definition: main.c:457
i32 ip4_get_port(ip4_header_t *ip, map_dir_e dir, u16 buffer_len)
Definition: map.c:66
u8 psid_length
Definition: map.h:97
map_ip4_reass_t * ip4_reass_pool
Definition: map.h:235
int map_ip4_reass_add_fragment(map_ip4_reass_t *r, u32 pi)
Definition: map.c:1431
u32 ip4_reass_conf_buffers
Definition: map.h:232
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:343
map_domain_flags_e flags
Definition: map.h:92
u16 fifo_prev
Definition: map.h:187
vlib_node_registration_t ip4_map_t_node
(constructor) VLIB_REGISTER_NODE (ip4_map_t_node)
Definition: ip4_map_t.c:1337
static_always_inline u64 map_get_pfx(map_domain_t *d, u32 addr, u16 port)
Definition: map.h:325
u16 ip4_reass_allocated
Definition: map.h:237
volatile u32 * ip6_reass_lock
Definition: map.h:263
volatile u32 * counter_lock
Definition: map.h:200
u8 ip4_reass_ht_log2len
Definition: map.h:236
u32 fragments[MAP_IP4_REASS_MAX_FRAGMENTS_PER_REASSEMBLY]
Definition: map.h:139
vlib_node_registration_t ip4_map_t_icmp_node
(constructor) VLIB_REGISTER_NODE (ip4_map_t_icmp_node)
Definition: ip4_map_t.c:1297
u16 bucket_next
Definition: map.h:186
u64 as_u64
Definition: bihash_doc.h:63
ip_lookup_next_t lookup_next_index
Definition: lookup.h:180
#define PREDICT_TRUE(x)
Definition: clib.h:98
u64 as_u64[2]
Definition: ip6_packet.h:50
IP unicast adjacency.
Definition: lookup.h:164
map_error_t
Definition: map.h:292
#define NULL
Definition: clib.h:55
int map_ip4_reass_conf_buffers(u32 buffers)
Definition: map.c:1754
static_always_inline int ip6_parse(const ip6_header_t *ip6, u32 buff_len, u8 *l4_protocol, u16 *l4_offset, u16 *frag_hdr_offset)
Definition: map.h:497
vlib_main_t * vlib_main
Definition: map.h:222
int map_ip6_reass_conf_lifetime(u16 lifetime_ms)
Definition: map.c:1830
u8 tc
Definition: map.h:210
int map_ip4_reass_conf_ht_ratio(f32 ht_ratio, u32 *trashed_reass, u32 *dropped_packets)
Definition: map.c:1715
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:482
static void map_domain_counter_unlock(map_main_t *mm)
Definition: map.h:545
struct _vlib_node_registration vlib_node_registration_t
u32 suffix_mask
Definition: map.h:88
bool sec_check_frag
Definition: map.h:214
ip_lookup_main_t lookup_main
Definition: ip4.h:115
u32 ip4_reass_buffered_counter
Definition: map.h:243
ip6_address_t preresolve_ip6
Definition: map.h:206
u16 ip4_reass_fifo_last
Definition: map.h:239
map_ip6_reass_t * ip6_reass_pool
Definition: map.h:258
u16 port
Definition: map.h:303
ip4_address_t preresolve_ip4
Definition: map.h:205
vlib_node_registration_t ip6_map_t_tcp_udp_node
(constructor) VLIB_REGISTER_NODE (ip6_map_t_tcp_udp_node)
Definition: ip6_map_t.c:1471
float f32
Definition: types.h:143
static_always_inline void ip4_map_t_embedded_address(map_domain_t *d, ip6_address_t *ip6, const ip4_address_t *ip4)
Definition: map.h:521
#define MAP_IP4_REASS_MAX_FRAGMENTS_PER_REASSEMBLY
Definition: map.h:65
static_always_inline u32 ip6_map_t_embedded_address(map_domain_t *d, ip6_address_t *addr)
Definition: map.h:531
bool tc_copy
Definition: map.h:211
#define static_always_inline
Definition: clib.h:85
map_ip4_reass_key_t key
Definition: map.h:128
u16 bucket
Definition: map.h:185
vlib_combined_counter_main_t * domain_counters
Definition: map.h:199
ip4_address_t icmp4_src_address
Definition: map.h:218
int i32
Definition: types.h:81
static_always_inline void map_send_all_to_node(vlib_main_t *vm, u32 *pi_vector, vlib_node_runtime_t *node, vlib_error_t *error, u32 next)
Definition: map.h:553
u16 fifo_next
Definition: map.h:138
u32 ip4_fib_lookup_with_table(ip4_main_t *im, u32 fib_index, ip4_address_t *dst, u32 disable_default_route)
Definition: ip4_forward.c:58
vlib_simple_counter_main_t icmp_relayed
Definition: map.h:219
int map_ip4_reass_conf_pool_size(u16 pool_size, u32 *trashed_reass, u32 *dropped_packets)
Definition: map.c:1732
ip6_address_t * rules
Definition: map.h:87
unsigned long u64
Definition: types.h:89
int map_ip6_reass_conf_ht_ratio(f32 ht_ratio, u32 *trashed_reass, u32 *dropped_packets)
Definition: map.c:1798
u8 ea_bits_len
Definition: map.h:95
A collection of simple counters.
Definition: counter.h:59
u8 ip6_prefix_len
Definition: map.h:93
int map_ip6_reass_conf_buffers(u32 buffers)
Definition: map.c:1837
u16 ip6_reass_allocated
Definition: map.h:260
map_ip4_reass_t * map_ip4_reass_get(u32 src, u32 dst, u16 fragment_id, u8 protocol, u32 **pi_to_drop)
Definition: map.c:1352
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:369
u32 vlib_error_t
Definition: error.h:44
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)
Definition: map.c:152
bool frag_ignore_df
Definition: map.h:246
volatile u32 * ip4_reass_lock
Definition: map.h:240
static_always_inline u64 map_get_pfx_net(map_domain_t *d, u32 addr, u16 port)
Definition: map.h:339
u16 ip4_reass_conf_pool_size
Definition: map.h:230
map_domain_t * domains
Definition: map.h:195
int map_ip6_reass_conf_pool_size(u16 pool_size, u32 *trashed_reass, u32 *dropped_packets)
Definition: map.c:1815
u16 bucket
Definition: map.h:135
This packet needs to go to MAP - RFC7596, RFC7597.
Definition: lookup.h:84
static_always_inline u64 map_get_sfx_net(map_domain_t *d, u32 addr, u16 port)
Definition: map.h:368
static_always_inline map_domain_t * ip6_map_get_domain(u32 adj_index, ip4_address_t *addr, u32 *map_domain_index, u8 *error)
Definition: map.h:402
u16 * ip6_reass_hash_table
Definition: map.h:261
u16 * ip4_reass_hash_table
Definition: map.h:238
map_main_t map_main
Definition: map.h:306
#define vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, bi0, next0)
Finish enqueueing one buffer forward in the graph.
Definition: buffer_node.h:130
u8 ip6_src_len
Definition: map.h:94
#define vlib_get_next_frame(vm, node, next_index, vectors, n_vectors_left)
Get pointer to next frame vector data by (vlib_node_runtime_t, next_index).
Definition: node_funcs.h:348
u8 psid_shift
Definition: map.h:100
u16 expected_total
Definition: map.h:131
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:118
vlib_node_registration_t ip4_map_t_tcp_udp_node
(constructor) VLIB_REGISTER_NODE (ip4_map_t_tcp_udp_node)
Definition: ip4_map_t.c:1317
u8 suffix_shift
Definition: map.h:101
vlib_node_registration_t ip4_map_t_fragmented_node
(constructor) VLIB_REGISTER_NODE (ip4_map_t_fragmented_node)
Definition: ip4_map_t.c:1277
u8 ip6_reass_ht_log2len
Definition: map.h:259
u32 as_u32[4]
Definition: ip6_packet.h:49
u16 ip6_reass_fifo_last
Definition: map.h:262
u16 ip6_reass_conf_pool_size
Definition: map.h:253
map_dir_e
Definition: map.h:23
u8 next_data_len
Definition: map.h:174
void map_ip4_drop_pi(u32 pi)
Definition: ip6_map.c:667
ip4_address_t ip4_prefix
Definition: map.h:89
u16 next_data_offset
Definition: map.h:173
static_always_inline void map_ip4_reass_get_fragments(map_ip4_reass_t *r, u32 **pi)
Definition: map.h:446
vlib_node_registration_t ip6_map_t_icmp_node
(constructor) VLIB_REGISTER_NODE (ip6_map_t_icmp_node)
Definition: ip6_map_t.c:1451
u8 psid_offset
Definition: map.h:96
void map_ip6_reass_free(map_ip6_reass_t *r, u32 **pi_to_drop)
Definition: map.c:1470
u16 forwarded
Definition: map.h:132
bool icmp6_enabled
Definition: map.h:215
map_domain_counter_t
Definition: map.h:145
map_ip6_reass_key_t key
Definition: map.h:179
#define foreach_map_error
Definition: map.h:273
ip6_address_t ip6_src
Definition: map.h:85
static void map_domain_counter_lock(map_main_t *mm)
Definition: map.h:538
f32 ip4_reass_conf_ht_ratio
Definition: map.h:229
vlib_node_registration_t ip4_map_node
(constructor) VLIB_REGISTER_NODE (ip4_map_node)
Definition: ip4_map.c:762
u16 cached_next_index
Definition: node.h:462
#define ASSERT(truth)
vlib_node_registration_t ip6_map_node
(constructor) VLIB_REGISTER_NODE (ip6_map_node)
Definition: ip6_map.c:1184
unsigned int u32
Definition: types.h:88
bool sec_check
Definition: map.h:213
ip6_main_t ip6_main
Definition: ip6_forward.c:2955
ip_lookup_main_t lookup_main
Definition: ip6.h:110
bool frag_inner
Definition: map.h:245
u16 psid_mask
Definition: map.h:90
IPv4 main type.
Definition: ip4.h:114
ip4_header_t ip4_header
Definition: map.h:189
u16 ip4_map_get_port(ip4_header_t *ip, map_dir_e dir)
Definition: ip4_map.c:69
u8 ea_shift
Definition: map.h:102
void map_ip6_drop_pi(u32 pi)
Definition: ip6_map.c:658
ip6_address_t ip6_prefix
Definition: map.h:86
u64 uword
Definition: types.h:112
f32 ip6_reass_conf_ht_ratio
Definition: map.h:252
u8 * format_map_trace(u8 *s, va_list *args)
Definition: map.c:1272
vnet_main_t * vnet_main
Definition: map.h:223
i32 ip6_get_port(ip6_header_t *ip6, map_dir_e dir, u16 buffer_len)
Definition: map.c:110
unsigned short u16
Definition: types.h:57
u16 mtu
Definition: map.h:91
u16 payload_length
Definition: ip6_packet.h:289
static_always_inline map_domain_t * ip4_map_get_domain(u32 adj_index, u32 *map_domain_index)
Definition: map.h:384
static_always_inline u32 map_get_ip4(ip6_address_t *addr)
Definition: map.h:375
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
double f64
Definition: types.h:142
u16 ip6_reass_conf_lifetime_ms
Definition: map.h:254
unsigned char u8
Definition: types.h:56
u32 adj6_index
Definition: map.h:204
i32 port
Definition: map.h:134
A collection of combined counters.
Definition: counter.h:212
u16 bucket_next
Definition: map.h:136
u8 ip4_prefix_len
Definition: map.h:105
vlib_simple_counter_main_t * simple_domain_counters
Definition: map.h:198
u64 map_error_counter_get(u32 node_index, map_error_t map_error)
Definition: map.c:978
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:1578
#define MAP_IP6_REASS_MAX_FRAGMENTS_PER_REASSEMBLY
Definition: map.h:72
void map_ip4_reass_free(map_ip4_reass_t *r, u32 **pi_to_drop)
Definition: map.c:1309
u16 ip4_reass_conf_lifetime_ms
Definition: map.h:231
int map_delete_domain(u32 map_domain_index)
Definition: map.c:320
static_always_inline u64 map_get_sfx(map_domain_t *d, u32 addr, u16 port)
Definition: map.h:349
u32 map_domain_index
Definition: map.h:302
int map_add_del_psid(u32 map_domain_index, u16 psid, ip6_address_t *tep, u8 is_add)
Definition: map.c:390
vhost_vring_addr_t addr
Definition: vhost-user.h:82
u16 fifo_prev
Definition: map.h:137
Definition: map.h:25
int map_ip4_reass_conf_lifetime(u16 lifetime_ms)
Definition: map.c:1747
vlib_node_registration_t ip6_map_t_fragmented_node
(constructor) VLIB_REGISTER_NODE (ip6_map_t_fragmented_node)
Definition: ip6_map_t.c:1431
This packet needs to go to MAP with Translation - RFC7599.
Definition: lookup.h:87
vlib_node_registration_t ip6_map_t_node
(constructor) VLIB_REGISTER_NODE (ip6_map_t_node)
Definition: ip6_map_t.c:1491
u32 flags
Definition: vhost-user.h:76
u32 ip6_reass_buffered_counter
Definition: map.h:266
u16 expected_total
Definition: map.h:182
map_domain_flags_e
Definition: map.h:42
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:69
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)
Definition: map.c:1603
u16 fifo_next
Definition: map.h:188
#define CLIB_PACKED(x)
Definition: clib.h:78
static ip_adjacency_t * ip_get_adjacency(ip_lookup_main_t *lm, u32 adj_index)
Definition: lookup.h:480
u32 ip6_reass_conf_buffers
Definition: map.h:255