FD.io VPP  v19.04.4-rc0-5-ge88582fac
Vector Packet Processing
ioam_cache.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017 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 #ifndef __included_ioam_cache_h__
16 #define __included_ioam_cache_h__
17 
18 #include <vnet/vnet.h>
19 #include <vnet/ip/ip.h>
20 #include <vnet/ip/ip_packet.h>
21 #include <vnet/ip/ip4_packet.h>
22 #include <vnet/ip/ip6_packet.h>
23 #include <vnet/srv6/sr.h>
24 
25 #include <vppinfra/pool.h>
26 #include <vppinfra/hash.h>
27 #include <vppinfra/error.h>
28 #include <vppinfra/elog.h>
29 #include <vppinfra/bihash_8_8.h>
32 /*
33  * ioam_cache.h
34  * This header contains routines for caching of ioam header and
35  * buffer:
36  * 1 - On application facing node: to cache ioam header recvd
37  * in request and reattach in response to provide round
38  * trip path visibility. Since request response matching
39  * is needed works with TCP and relies on (5 tuples,seq no)
40  * 2 - On M-Anycast server node: This node replicates requests
41  * towards multiple anycast service nodes serving anycast
42  * IP6 address. It evaluates response and forwards the best
43  * response towards the client of requesting the service.
44  * Again since request-response matching is needed, works
45  * with TCP and relies on (5 tuples,seq no) for matching.
46  * To do this it caches SYN-ACK responses for a short time to
47  * evaluate multiple responses received before the selected
48  * SYN-ACK response is forwared and others dropped.
49  *
50  * M-Anycast server cache:
51  * - There is a pool of cache entries per worker thread.
52  * - Cache entry is created when SYN is received expected
53  * number of responses are marked based on number of
54  * SR tunnels for the anycast destination address
55  * - The pool/thread id and pool index are attached in the
56  * message as an ioam option for quick look up.
57  * - When is received SYN-ACK the ioam option containing
58  * thread id + pool index of the cache entry is used to
59  * look up cache entry.
60  * - Cache synchronization:
61  * - This is achieved by cache entry add/del/update all handled
62  * by the same worker/main thread
63  * - Packets from client to threads - syn packets, can be disctributed
64  * based on incoming interface affinity to the cpu core pinned to
65  * the thread or a simple sequence number based distribution
66  * if thread per interface is not scaling
67  * - Response packets from server towards clients - syn-acks, are
68  * forced to the same thread that created the cache entry
69  * using SR and the destination of SR v6 address assigned
70  * to the core/thread. This adderss is sent as an ioam option
71  * in the syn that can be then used on the other side to
72  * populate v6 dst address in the response
73  * - Timeout: timer wheel per thread is used to track the syn-ack wait
74  * time. The timer wheel tick is updated via an input node per thread.
75  *
76  * Application facing node/Service side cache:
77  * - Single pool of cache entries.
78  * - Cache entry is created when SYN is received. Caches the ioam
79  * header. Hash table entry is created based on 5 tuple and
80  * TCP seq no to pool index
81  * - Response SYN-ACK processed by looking up pool index in hash table
82  * and cache entry in the pool is used to get the ioam header rewrite
83  * string. Entry is freed from pool and hash table after use.
84  * - Locking/Synchronization: Currently this functionality is deployed
85  * with main/single thread only. Hence no locking is used.
86  * - Deployment: A VPP node per application server servicing anycast
87  * address is expected. Locking/synchronization needed when the server
88  * /application facing node is started with multiple worker threads.
89  *
90  */
91 
92 /*
93  * Application facing server side caching:
94  * Cache entry for ioam header
95  * Currently caters to TCP and relies on
96  * TCP - 5 tuples + seqno to cache and reinsert
97  * ioam header b/n TCP request response
98  */
99 typedef struct
100 {
101  /** Required for pool_get_aligned */
102  CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
113 
114 /*
115  * Cache entry for anycast server selection
116  * Works for TCP as 5 tuple + sequence number
117  * is required for request response matching
118  * max_responses expected is set based on number
119  * of SR tunnels for the dst_address
120  * Timeout or all response_received = max_responses
121  * will clear the entry
122  * buffer_index index of the response msg vlib buffer
123  * that is currently the best response
124  */
125 typedef struct
126 {
127  /** Required for pool_get_aligned */
128  CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
138  ip6_hop_by_hop_header_t *hbh; //pointer to hbh header in the buffer
143  /** Handle returned from tw_start_timer */
145  /** entry should expire at this clock tick */
148 
149 /*
150  * Per thread tunnel selection cache stats
151  */
152 typedef struct
153 {
157 
158 /* Server side: iOAM header caching */
159 #define MAX_CACHE_ENTRIES 4096
160 /* M-Anycast: Cache for SR tunnel selection */
161 #define MAX_CACHE_TS_ENTRIES 1048576
162 
163 #define IOAM_CACHE_TABLE_DEFAULT_HASH_NUM_BUCKETS (4 * 1024)
164 #define IOAM_CACHE_TABLE_DEFAULT_HASH_MEMORY_SIZE (2<<20)
165 
166 typedef struct
167 {
168  /* API message ID base */
170 
171  /* Pool of ioam_cache_buffer_t */
173 
174  /* For steering packets ioam cache entry is followed by
175  * SR header. This is the SR rewrite template */
177  /* The current rewrite string being used */
181 
184  clib_bihash_8_8_t ioam_rewrite_cache_table;
185 
186  /* M-Anycast: Pool of ioam_cache_ts_entry_t per thread */
189  /** per thread single-wheel */
190  tw_timer_wheel_16t_2w_512sl_t *timer_wheels;
191 
192  /*
193  * Selection criteria: oneway delay: Server to M-Anycast
194  * or RTT
195  */
199 
200  /* convenience */
202 
208 
212 
214 
217 
218 /* Compute flow hash. We'll use it to select which Sponge to use for this
219  * flow. And other things.
220  * ip6_compute_flow_hash in ip6.h doesnt locate tcp/udp when
221  * ext headers are present. While it could be made to it will be a
222  * performance hit for ECMP flows.
223  * HEnce this function here, with L4 information directly input
224  * Useful when tcp/udp headers are already located in presence of
225  * ext headers
226  */
229  u8 protocol,
230  u16 src_port,
231  u16 dst_port, flow_hash_config_t flow_hash_config)
232 {
233  u64 a, b, c;
234  u64 t1, t2;
235 
236  t1 = (ip->src_address.as_u64[0] ^ ip->src_address.as_u64[1]);
237  t1 = (flow_hash_config & IP_FLOW_HASH_SRC_ADDR) ? t1 : 0;
238 
239  t2 = (ip->dst_address.as_u64[0] ^ ip->dst_address.as_u64[1]);
240  t2 = (flow_hash_config & IP_FLOW_HASH_DST_ADDR) ? t2 : 0;
241 
242  a = (flow_hash_config & IP_FLOW_HASH_REVERSE_SRC_DST) ? t2 : t1;
243  b = (flow_hash_config & IP_FLOW_HASH_REVERSE_SRC_DST) ? t1 : t2;
244  b ^= (flow_hash_config & IP_FLOW_HASH_PROTO) ? protocol : 0;
245 
246  t1 = src_port;
247  t2 = dst_port;
248 
249  t1 = (flow_hash_config & IP_FLOW_HASH_SRC_PORT) ? t1 : 0;
250  t2 = (flow_hash_config & IP_FLOW_HASH_DST_PORT) ? t2 : 0;
251 
252  c = (flow_hash_config & IP_FLOW_HASH_REVERSE_SRC_DST) ?
253  ((t1 << 16) | t2) : ((t2 << 16) | t1);
254 
255  hash_mix64 (a, b, c);
256  return (u32) c;
257 }
258 
259 
260 /* 2 new ioam E2E options :
261  * 1. HBH_OPTION_TYPE_IOAM_EDGE_TO_EDGE_ID: IP6 address
262  * of ioam node that inserted ioam header
263  * 2. HBH_OPTION_TYPE_IOAM_E2E_CACHE_ID: Pool id and index
264  * to look up tunnel select cache entry
265  */
266 #define HBH_OPTION_TYPE_IOAM_EDGE_TO_EDGE_ID 30
267 #define HBH_OPTION_TYPE_IOAM_E2E_CACHE_ID 31
268 
269 typedef CLIB_PACKED (struct
270  {
271  ip6_hop_by_hop_option_t hdr; u8 e2e_type; u8 reserved[5];
273  }) ioam_e2e_id_option_t;
274 
275 typedef CLIB_PACKED (struct
276  {
277  ip6_hop_by_hop_option_t hdr; u8 e2e_type; u8 pool_id;
278  u32 pool_index;
279  }) ioam_e2e_cache_option_t;
280 
281 #define IOAM_E2E_ID_OPTION_RND ((sizeof(ioam_e2e_id_option_t) + 7) & ~7)
282 #define IOAM_E2E_ID_HBH_EXT_LEN (IOAM_E2E_ID_OPTION_RND >> 3)
283 #define IOAM_E2E_CACHE_OPTION_RND ((sizeof(ioam_e2e_cache_option_t) + 7) & ~7)
284 #define IOAM_E2E_CACHE_HBH_EXT_LEN (IOAM_E2E_CACHE_OPTION_RND >> 3)
285 
286 static inline void
287 ioam_e2e_id_rewrite_handler (ioam_e2e_id_option_t * e2e_option,
289 {
290  e2e_option->id.as_u64[0] = address->as_u64[0];
291  e2e_option->id.as_u64[1] = address->as_u64[1];
292 
293 }
294 
295 /* Following functions are for the caching of ioam header
296  * to enable reattaching it for a complete request-response
297  * message exchange */
298 inline static void
300 {
302  if (entry)
303  {
304  vec_free (entry->ioam_rewrite_string);
305  clib_memset (entry, 0, sizeof (*entry));
306  pool_put (cm->ioam_rewrite_pool, entry);
307  }
308 }
309 
310 inline static ioam_cache_entry_t *
312 {
314  ioam_cache_entry_t *entry = 0;
315 
316  entry = pool_elt_at_index (cm->ioam_rewrite_pool, pool_index);
317  ioam_cache_entry_free (entry);
318  return (0);
319 }
320 
321 inline static ioam_cache_entry_t *
323 {
325  u32 flow_hash = ip6_compute_flow_hash_ext (ip0, ip0->protocol,
326  src_port, dst_port,
329  clib_bihash_kv_8_8_t kv, value;
330 
331  kv.key = (u64) flow_hash << 32 | seq_no;
332  kv.value = 0;
333  value.key = 0;
334  value.value = 0;
335 
336  if (clib_bihash_search_8_8 (&cm->ioam_rewrite_cache_table, &kv, &value) >=
337  0)
338  {
339  ioam_cache_entry_t *entry = 0;
340 
341  entry = pool_elt_at_index (cm->ioam_rewrite_pool, value.value);
342  /* match */
343  if (ip6_address_compare (&ip0->src_address, &entry->dst_address) == 0 &&
344  ip6_address_compare (&ip0->dst_address, &entry->src_address) == 0 &&
345  entry->src_port == dst_port &&
346  entry->dst_port == src_port && entry->seq_no == seq_no)
347  {
348  /* If lookup is successful remove it from the hash */
349  clib_bihash_add_del_8_8 (&cm->ioam_rewrite_cache_table, &kv, 0);
350  return (entry);
351  }
352  else
353  return (0);
354 
355  }
356  return (0);
357 }
358 
359 /*
360  * Caches ioam hbh header
361  * Extends the hbh header with option to contain IP6 address of the node
362  * that caches it
363  */
364 inline static int
366  ip6_header_t * ip0,
367  u16 src_port,
368  u16 dst_port, ip6_hop_by_hop_header_t * hbh0, u32 seq_no)
369 {
371  ioam_cache_entry_t *entry = 0;
372  u32 rewrite_len = 0, e2e_id_offset = 0;
373  u32 pool_index = 0;
374  ioam_e2e_id_option_t *e2e = 0;
375 
377  clib_memset (entry, 0, sizeof (*entry));
378  pool_index = entry - cm->ioam_rewrite_pool;
379 
381  sizeof (ip6_address_t));
383  sizeof (ip6_address_t));
384  entry->src_port = src_port;
385  entry->dst_port = dst_port;
386  entry->seq_no = seq_no;
387  rewrite_len = ((hbh0->length + 1) << 3);
388  vec_validate (entry->ioam_rewrite_string, rewrite_len - 1);
390  if (e2e)
391  {
392  entry->next_hop.as_u64[0] = e2e->id.as_u64[0];
393  entry->next_hop.as_u64[1] = e2e->id.as_u64[1];
394  }
395  else
396  {
397  return (-1);
398  }
399  e2e_id_offset = (u8 *) e2e - (u8 *) hbh0;
400  /* setup e2e id option to insert v6 address of the node caching it */
401  clib_memcpy_fast (entry->ioam_rewrite_string, hbh0, rewrite_len);
403 
404  /* suffix rewrite string with e2e ID option */
405  e2e = (ioam_e2e_id_option_t *) (entry->ioam_rewrite_string + e2e_id_offset);
407  entry->my_address_offset = (u8 *) (&e2e->id) - (u8 *) hbh0;
408 
409  /* add it to hash, replacing and freeing any collision for now */
410  u32 flow_hash =
411  ip6_compute_flow_hash_ext (ip0, hbh0->protocol, src_port, dst_port,
413  clib_bihash_kv_8_8_t kv, value;
414  kv.key = (u64) flow_hash << 32 | seq_no;
415  kv.value = 0;
416  if (clib_bihash_search_8_8 (&cm->ioam_rewrite_cache_table, &kv, &value) >=
417  0)
418  {
419  /* replace */
421  }
422  kv.value = pool_index;
423  clib_bihash_add_del_8_8 (&cm->ioam_rewrite_cache_table, &kv, 1);
424  return (0);
425 }
426 
427 /* Creates SR rewrite string
428  * This is appended with ioam header on the server facing
429  * node.
430  * This SR header is necessary to attract packets towards
431  * selected Anycast server.
432  */
433 inline static void
435 {
437  ip6_address_t *segments = 0;
438  ip6_address_t *this_seg = 0;
439 
440  /* This nodes address and the original dest will be
441  * filled when the packet is processed */
442  vec_add2 (segments, this_seg, 1);
443  clib_memset (this_seg, 0xfe, sizeof (ip6_address_t));
445  vec_free (segments);
446 }
447 
448 inline static int
450 {
452 
458 
459  clib_bihash_init_8_8 (&cm->ioam_rewrite_cache_table,
460  "ioam rewrite cache table",
462  /* Create SR rewrite template */
464  return (1);
465 }
466 
467 inline static int
469 {
471  ioam_cache_entry_t *entry = 0;
472  /* free pool and hash table */
473  clib_bihash_free_8_8 (&cm->ioam_rewrite_cache_table);
474  pool_foreach (entry, cm->ioam_rewrite_pool, (
475  {
476  ioam_cache_entry_free (entry);
477  }));
479  cm->ioam_rewrite_pool = 0;
481  cm->sr_rewrite_template = 0;
482  return (0);
483 }
484 
485 inline static u8 *
486 format_ioam_cache_entry (u8 * s, va_list * args)
487 {
488  ioam_cache_entry_t *e = va_arg (*args, ioam_cache_entry_t *);
490  int rewrite_len = vec_len (e->ioam_rewrite_string);
491 
492  s = format (s, "%d: %U:%d to %U:%d seq_no %lu\n",
493  (e - cm->ioam_rewrite_pool),
495  e->src_port,
497 
498  if (rewrite_len)
499  {
500  s = format (s, " %U",
503  rewrite_len - 1);
504  }
505  return s;
506 }
507 
509 
510 #define IOAM_CACHE_TS_TIMEOUT 1.0 //SYN timeout 1 sec
511 #define IOAM_CACHE_TS_TICK 100e-3
512 /* Timer delays as multiples of 100ms */
513 #define IOAM_CACHE_TS_TIMEOUT_TICKS IOAM_CACHE_TS_TICK*9
514 #define TIMER_HANDLE_INVALID ((u32) ~0)
515 
516 
517 void expired_cache_ts_timer_callback (u32 * expired_timers);
518 
519 /*
520  * Following functions are to manage M-Anycast server selection
521  * cache
522  * There is a per worker thread pool to create a cache entry
523  * for a TCP SYN received. TCP SYN-ACK contians ioam header
524  * with HBH_OPTION_TYPE_IOAM_E2E_CACHE_ID option to point to the
525  * entry.
526  */
527 inline static int
529 {
531  int no_of_threads = vec_len (vlib_worker_threads);
532  int i;
533 
534  vec_validate_aligned (cm->ioam_ts_pool, no_of_threads - 1,
536  vec_validate_aligned (cm->ts_stats, no_of_threads - 1,
538  vec_validate (cm->timer_wheels, no_of_threads - 1);
542  for (i = 0; i < no_of_threads; i++)
543  {
546  clib_memset (&cm->ts_stats[i], 0, sizeof (ioam_cache_ts_pool_stats_t));
547  tw_timer_wheel_init_16t_2w_512sl (&cm->timer_wheels[i],
550  /* timer period 100ms */ ,
551  10e4);
552  cm->timer_wheels[i].last_run_time = vlib_time_now (vm);
553  }
555  return (1);
556 }
557 
558 always_inline void
560  ioam_cache_ts_entry_t * entry, u32 interval)
561 {
562  entry->timer_handle
563  = tw_timer_start_16t_2w_512sl (&cm->timer_wheels[entry->pool_id],
564  entry->pool_index, 1, interval);
565 }
566 
567 always_inline void
569  ioam_cache_ts_entry_t * entry)
570 {
571  tw_timer_stop_16t_2w_512sl (&cm->timer_wheels[entry->pool_id],
572  entry->timer_handle);
574 }
575 
576 inline static void
578  ioam_cache_ts_entry_t * entry, u32 node_index)
579 {
581  vlib_main_t *vm = cm->vlib_main;
582  vlib_frame_t *nf = 0;
583  u32 *to_next;
584 
585  if (entry)
586  {
587  if (entry->hbh != 0)
588  {
589  nf = vlib_get_frame_to_node (vm, node_index);
590  nf->n_vectors = 0;
591  to_next = vlib_frame_vector_args (nf);
592  nf->n_vectors = 1;
593  to_next[0] = entry->buffer_index;
594  vlib_put_frame_to_node (vm, node_index, nf);
595  }
596  pool_put (cm->ioam_ts_pool[thread_id], entry);
597  cm->ts_stats[thread_id].inuse--;
598  clib_memset (entry, 0, sizeof (*entry));
599  }
600 }
601 
602 inline static int
604 {
606  ioam_cache_ts_entry_t *entry = 0;
607  int no_of_threads = vec_len (vlib_worker_threads);
608  int i;
609 
610  /* free pool and hash table */
611  for (i = 0; i < no_of_threads; i++)
612  {
613  pool_foreach (entry, cm->ioam_ts_pool[i], (
614  {
615  ioam_cache_ts_entry_free (i,
616  entry,
617  cm->error_node_index);
618  }
619  ));
620  pool_free (cm->ioam_ts_pool[i]);
621  cm->ioam_ts_pool = 0;
622  tw_timer_wheel_free_16t_2w_512sl (&cm->timer_wheels[i]);
623  }
624  vec_free (cm->ioam_ts_pool);
625  return (0);
626 }
627 
628 inline static int
629 ioam_cache_ts_entry_cleanup (u32 thread_id, u32 pool_index)
630 {
632  ioam_cache_ts_entry_t *entry = 0;
633 
634  entry = pool_elt_at_index (cm->ioam_ts_pool[thread_id], pool_index);
635  ioam_cache_ts_entry_free (thread_id, entry, cm->error_node_index);
636  return (0);
637 }
638 
639 /*
640  * Caches buffer for ioam SR tunnel select for Anycast service
641  */
642 inline static int
644  u16 src_port,
645  u16 dst_port,
646  u32 seq_no,
647  u8 max_responses, u64 now, u32 thread_id, u32 * pool_index)
648 {
650  ioam_cache_ts_entry_t *entry = 0;
651 
652  if (cm->ts_stats[thread_id].inuse == MAX_CACHE_TS_ENTRIES)
653  {
654  cm->ts_stats[thread_id].add_failed++;
655  return (-1);
656  }
657 
658  pool_get_aligned (cm->ioam_ts_pool[thread_id], entry,
660  clib_memset (entry, 0, sizeof (*entry));
661  *pool_index = entry - cm->ioam_ts_pool[thread_id];
662 
664  sizeof (ip6_address_t));
666  sizeof (ip6_address_t));
667  entry->src_port = src_port;
668  entry->dst_port = dst_port;
669  entry->seq_no = seq_no;
670  entry->response_received = 0;
671  entry->max_responses = max_responses;
672  entry->created_at = now;
673  entry->hbh = 0;
674  entry->buffer_index = 0;
675  entry->pool_id = thread_id;
676  entry->pool_index = *pool_index;
678  cm->ts_stats[thread_id].inuse++;
679  return (0);
680 }
681 
682 inline static void
683 ioam_cache_ts_send (u32 thread_id, i32 pool_index)
684 {
686  ioam_cache_ts_entry_t *entry = 0;
687 
688  entry = pool_elt_at_index (cm->ioam_ts_pool[thread_id], pool_index);
689  if (!pool_is_free (cm->ioam_ts_pool[thread_id], entry) && entry)
690  {
691  /* send and free pool entry */
692  ioam_cache_ts_entry_free (thread_id, entry, cm->ip6_hbh_pop_node_index);
693  }
694 }
695 
696 inline static void
697 ioam_cache_ts_check_and_send (u32 thread_id, i32 pool_index)
698 {
700  ioam_cache_ts_entry_t *entry = 0;
701  entry = pool_elt_at_index (cm->ioam_ts_pool[thread_id], pool_index);
702  if (entry && entry->hbh)
703  {
704  if (entry->response_received == entry->max_responses ||
706  vlib_time_now (cm->vlib_main))
707  {
708  ioam_cache_ts_timer_reset (cm, entry);
709  ioam_cache_ts_send (thread_id, pool_index);
710  }
711  }
712 }
713 
714 inline static int
716  i32 pool_index,
717  u32 buffer_index, ip6_hop_by_hop_header_t * hbh)
718 {
720  ioam_cache_ts_entry_t *entry = 0;
721  vlib_main_t *vm = cm->vlib_main;
722  vlib_frame_t *nf = 0;
723  u32 *to_next;
724 
725  entry = pool_elt_at_index (cm->ioam_ts_pool[thread_id], pool_index);
726  if (!pool_is_free (cm->ioam_ts_pool[thread_id], entry) && entry)
727  {
728  /* drop existing buffer */
729  if (entry->hbh != 0)
730  {
732  nf->n_vectors = 0;
733  to_next = vlib_frame_vector_args (nf);
734  nf->n_vectors = 1;
735  to_next[0] = entry->buffer_index;
737  }
738  /* update */
739  entry->buffer_index = buffer_index;
740  entry->hbh = hbh;
741  /* check and send */
742  ioam_cache_ts_check_and_send (thread_id, pool_index);
743  return (0);
744  }
745  return (-1);
746 }
747 
748 /*
749  * looks up the entry based on the e2e option pool index
750  * result = 0 found the entry
751  * result < 0 indicates failture to find an entry
752  */
753 inline static int
755  u8 protocol,
756  u16 src_port,
757  u16 dst_port,
758  u32 seq_no,
760  u32 * pool_index, u8 * thread_id, u8 response_seen)
761 {
763  ip6_hop_by_hop_header_t *hbh0 = 0;
764  ioam_e2e_cache_option_t *e2e = 0;
765 
766  hbh0 = (ip6_hop_by_hop_header_t *) (ip0 + 1);
767  e2e =
768  (ioam_e2e_cache_option_t *) ((u8 *) hbh0 + cm->rewrite_pool_index_offset);
769  if ((u8 *) e2e < ((u8 *) hbh0 + ((hbh0->length + 1) << 3))
770  && e2e->hdr.type == HBH_OPTION_TYPE_IOAM_E2E_CACHE_ID)
771  {
772  ioam_cache_ts_entry_t *entry = 0;
773  *pool_index = e2e->pool_index;
774  *thread_id = e2e->pool_id;
775  entry = pool_elt_at_index (cm->ioam_ts_pool[*thread_id], *pool_index);
776  /* match */
777  if (entry &&
778  ip6_address_compare (&ip0->src_address, &entry->dst_address) == 0 &&
779  ip6_address_compare (&ip0->dst_address, &entry->src_address) == 0 &&
780  entry->src_port == dst_port &&
781  entry->dst_port == src_port && entry->seq_no == seq_no)
782  {
783  *hbh = entry->hbh;
784  entry->response_received += response_seen;
785  return (0);
786  }
787  else if (entry)
788  {
789  return (-1);
790  }
791  }
792  return (-1);
793 }
794 
795 inline static u8 *
796 format_ioam_cache_ts_entry (u8 * s, va_list * args)
797 {
798  ioam_cache_ts_entry_t *e = va_arg (*args, ioam_cache_ts_entry_t *);
799  u32 thread_id = va_arg (*args, u32);
801  ioam_e2e_id_option_t *e2e = 0;
802  vlib_main_t *vm = cm->vlib_main;
803  clib_time_t *ct = &vm->clib_time;
804 
805  if (!e)
806  goto end;
807 
808  if (e->hbh)
809  {
810  e2e =
813 
814  s =
815  format (s,
816  "%d: %U:%d to %U:%d seq_no %u buffer %u %U \n\t\tCreated at %U Received %d\n",
817  (e - cm->ioam_ts_pool[thread_id]), format_ip6_address,
819  &e->dst_address, e->dst_port, e->seq_no, e->buffer_index,
820  format_ip6_address, e2e ? &e2e->id : 0, format_time_interval,
821  "h:m:s:u",
822  (e->created_at -
824  e->response_received);
825  }
826  else
827  {
828  s =
829  format (s,
830  "%d: %U:%d to %U:%d seq_no %u Buffer %u \n\t\tCreated at %U Received %d\n",
831  (e - cm->ioam_ts_pool[thread_id]), format_ip6_address,
833  &e->dst_address, e->dst_port, e->seq_no, e->buffer_index,
834  format_time_interval, "h:m:s:u",
835  (e->created_at -
837  e->response_received);
838  }
839 
840 end:
841  return s;
842 }
843 
844 /*
845  * Get extended rewrite string for iOAM data in v6
846  * This makes space for an e2e options to carry cache pool info
847  * and manycast server address.
848  * It set the rewrite string per configs in ioam ip6 + new option
849  * for cache along with offset to the option to populate cache
850  * pool id and index
851  */
852 static inline int
854 {
858  u32 rewrite_len = 0;
859  ioam_e2e_cache_option_t *e2e = 0;
860  ioam_e2e_id_option_t *e2e_id = 0;
861 
862  vec_free (cm->rewrite);
865  hbh = (ip6_hop_by_hop_header_t *) cm->rewrite;
866  rewrite_len = ((hbh->length + 1) << 3);
867  vec_validate (cm->rewrite,
868  rewrite_len - 1 + IOAM_E2E_CACHE_OPTION_RND +
870  hbh = (ip6_hop_by_hop_header_t *) cm->rewrite;
871  /* setup e2e id option to insert pool id and index of the node caching it */
873  cm->rewrite_pool_index_offset = rewrite_len;
874  e2e = (ioam_e2e_cache_option_t *) (cm->rewrite + rewrite_len);
875  e2e->hdr.type = HBH_OPTION_TYPE_IOAM_E2E_CACHE_ID
877  e2e->hdr.length = sizeof (ioam_e2e_cache_option_t) -
878  sizeof (ip6_hop_by_hop_option_t);
879  e2e->e2e_type = 2;
880  e2e_id =
881  (ioam_e2e_id_option_t *) ((u8 *) e2e + sizeof (ioam_e2e_cache_option_t));
882  e2e_id->hdr.type =
884  e2e_id->hdr.length =
885  sizeof (ioam_e2e_id_option_t) - sizeof (ip6_hop_by_hop_option_t);
886  e2e_id->e2e_type = 1;
887 
888  return (0);
889 }
890 
891 static inline int
893 {
895 
896  vec_free (cm->rewrite);
897  cm->rewrite = 0;
899  return (0);
900 }
901 #endif /* __included_ioam_cache_h__ */
902 
903 /*
904  * fd.io coding-style-patch-verification: ON
905  *
906  * Local Variables:
907  * eval: (c-set-style "gnu")
908  * End:
909  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:439
u8 rewrite_pool_index_offset
Definition: ioam_cache.h:179
ip6_address_t sr_localsid_ts
Definition: ioam_cache.h:198
ip6_hop_by_hop_ioam_main_t ip6_hop_by_hop_ioam_main
#define MAX_CACHE_TS_ENTRIES
Definition: ioam_cache.h:161
typedef address
Definition: ip_types.api:30
ioam_cache_entry_t * ioam_rewrite_pool
Definition: ioam_cache.h:172
#define CLIB_CACHE_LINE_ALIGN_MARK(mark)
Definition: cache.h:60
static int ioam_cache_ts_table_init(vlib_main_t *vm)
Definition: ioam_cache.h:528
static ioam_cache_entry_t * ioam_cache_lookup(ip6_header_t *ip0, u16 src_port, u16 dst_port, u32 seq_no)
Definition: ioam_cache.h:322
static void ioam_cache_ts_entry_free(u32 thread_id, ioam_cache_ts_entry_t *entry, u32 node_index)
Definition: ioam_cache.h:577
a
Definition: bitmap.h:538
#define MAX_CACHE_ENTRIES
Definition: ioam_cache.h:159
#define IP_FLOW_HASH_SRC_PORT
Definition: lookup.h:64
#define IOAM_E2E_CACHE_HBH_EXT_LEN
Definition: ioam_cache.h:284
typedef CLIB_PACKED(struct { ip6_hop_by_hop_option_t hdr;u8 e2e_type;u8 reserved[5];ip6_address_t id;}) ioam_e2e_id_option_t
u8 protocol
Definition: ioam_cache.h:135
#define TIMER_HANDLE_INVALID
Definition: ioam_cache.h:514
u64 as_u64[2]
Definition: ip6_packet.h:51
#define IOAM_CACHE_TABLE_DEFAULT_HASH_NUM_BUCKETS
Definition: ioam_cache.h:163
unsigned long u64
Definition: types.h:89
Fixed length block allocator.
#define clib_memcpy_fast(a, b, c)
Definition: string.h:81
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:255
u32 seq_no
Definition: ioam_cache.h:108
#define IP_FLOW_HASH_REVERSE_SRC_DST
Definition: lookup.h:66
u8 * sr_rewrite_template
Definition: ioam_cache.h:176
static int ioam_cache_table_init(vlib_main_t *vm)
Definition: ioam_cache.h:449
static int ioam_cache_table_destroy(vlib_main_t *vm)
Definition: ioam_cache.h:468
ip6_address_t src_address
Definition: ioam_cache.h:131
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:560
int i
u16 dst_port
Definition: ioam_cache.h:106
#define IP_FLOW_HASH_DST_PORT
Definition: lookup.h:65
ip6_address_t dst_address
Definition: ioam_cache.h:104
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
clib_time_t clib_time
Definition: main.h:72
#define pool_is_free(P, E)
Use free bitmap to query whether given element is free.
Definition: pool.h:275
#define vec_validate_aligned(V, I, A)
Make sure vector is long enough for given index (no header, specified alignment)
Definition: vec.h:450
static void ioam_cache_ts_timer_set(ioam_cache_main_t *cm, ioam_cache_ts_entry_t *entry, u32 interval)
Definition: ioam_cache.h:559
static int ioam_cache_ts_update(u32 thread_id, i32 pool_index, u32 buffer_index, ip6_hop_by_hop_header_t *hbh)
Definition: ioam_cache.h:715
ip6_address_t src_address
Definition: ip6_packet.h:385
unsigned char u8
Definition: types.h:56
Definition: ioam_cache.h:99
u16 src_port
Definition: udp.api:41
static u8 * format_ioam_cache_ts_entry(u8 *s, va_list *args)
Definition: ioam_cache.h:796
ip6_address_t sr_localsid_cache
Definition: ioam_cache.h:180
static void ioam_cache_sr_rewrite_template_create(void)
Definition: ioam_cache.h:434
static ioam_cache_entry_t * ioam_cache_entry_cleanup(u32 pool_index)
Definition: ioam_cache.h:311
static int ip6_ioam_ts_cache_set_rewrite(void)
Definition: ioam_cache.h:853
u8 * format_ip6_hop_by_hop_ext_hdr(u8 *s, va_list *args)
Definition: ip6_forward.c:2189
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:493
static int ioam_cache_add(vlib_buffer_t *b0, ip6_header_t *ip0, u16 src_port, u16 dst_port, ip6_hop_by_hop_header_t *hbh0, u32 seq_no)
Definition: ioam_cache.h:365
#define IP_FLOW_HASH_DST_ADDR
Definition: lookup.h:62
#define pool_alloc_aligned(P, N, A)
Allocate N more free elements to pool (general version).
Definition: pool.h:318
#define always_inline
Definition: clib.h:98
u64 created_at
Definition: ioam_cache.h:139
u8 protocol
Definition: ioam_cache.h:107
static int ioam_cache_ts_add(ip6_header_t *ip0, u16 src_port, u16 dst_port, u32 seq_no, u8 max_responses, u64 now, u32 thread_id, u32 *pool_index)
Definition: ioam_cache.h:643
#define IOAM_CACHE_TABLE_DEFAULT_HASH_MEMORY_SIZE
Definition: ioam_cache.h:164
vlib_frame_t * vlib_get_frame_to_node(vlib_main_t *vm, u32 to_node_index)
Definition: main.c:187
static u32 ip6_compute_flow_hash_ext(const ip6_header_t *ip, u8 protocol, u16 src_port, u16 dst_port, flow_hash_config_t flow_hash_config)
Definition: ioam_cache.h:228
u32 ip6_reset_ts_hbh_node_index
Definition: ioam_cache.h:210
unsigned int u32
Definition: types.h:88
u64 cpu_time_main_loop_start
Definition: main.h:81
#define HBH_OPTION_TYPE_IOAM_EDGE_TO_EDGE_ID
Definition: ioam_cache.h:266
tw_timer_wheel_16t_2w_512sl_t * timer_wheels
per thread single-wheel
Definition: ioam_cache.h:190
static void ioam_cache_ts_check_and_send(u32 thread_id, i32 pool_index)
Definition: ioam_cache.h:697
static void ioam_e2e_id_rewrite_handler(ioam_e2e_id_option_t *e2e_option, ip6_address_t *address)
Definition: ioam_cache.h:287
int ip6_ioam_set_rewrite(u8 **rwp, int has_trace_option, int has_pot_option, int has_seqno_option)
vlib_node_registration_t ioam_cache_ts_node
(constructor) VLIB_REGISTER_NODE (ioam_cache_ts_node)
u16 src_port
Definition: ioam_cache.h:105
ioam_cache_ts_pool_stats_t * ts_stats
Definition: ioam_cache.h:188
u32 seq_no
Definition: ioam_cache.h:136
u8 response_received
Definition: ioam_cache.h:140
vlib_worker_thread_t * vlib_worker_threads
Definition: threads.c:36
Definition: ioam_cache.h:125
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:514
#define IOAM_CACHE_TS_TIMEOUT
Definition: ioam_cache.h:510
u64 key
the key
Definition: bihash_8_8.h:33
ioam_cache_ts_entry_t ** ioam_ts_pool
Definition: ioam_cache.h:187
vlib_node_registration_t ioam_cache_node
(constructor) VLIB_REGISTER_NODE (ioam_cache_node)
static int ip6_ioam_ts_cache_cleanup_rewrite(void)
Definition: ioam_cache.h:892
unsigned short u16
Definition: types.h:57
#define IOAM_E2E_ID_HBH_EXT_LEN
Definition: ioam_cache.h:282
u32 ip6_hbh_pop_node_index
Definition: ioam_cache.h:205
void vlib_put_frame_to_node(vlib_main_t *vm, u32 to_node_index, vlib_frame_t *f)
Definition: main.c:196
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:286
ip6_address_t src_address
Definition: ioam_cache.h:103
int ip6_address_compare(ip6_address_t *a1, ip6_address_t *a2)
Definition: ip46_cli.c:60
static void ioam_cache_entry_free(ioam_cache_entry_t *entry)
Definition: ioam_cache.h:299
static int ioam_cache_ts_lookup(ip6_header_t *ip0, u8 protocol, u16 src_port, u16 dst_port, u32 seq_no, ip6_hop_by_hop_header_t **hbh, u32 *pool_index, u8 *thread_id, u8 response_seen)
Definition: ioam_cache.h:754
f64 seconds_per_clock
Definition: time.h:57
ip6_address_t next_hop
Definition: ioam_cache.h:109
u32 cleanup_process_node_index
Definition: ioam_cache.h:207
u32 expected_to_expire
entry should expire at this clock tick
Definition: ioam_cache.h:146
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P with alignment A.
Definition: pool.h:230
#define pool_free(p)
Free a pool.
Definition: pool.h:407
The fine-grained event logger allows lightweight, thread-safe event logging at minimum cost...
u64 value
the value
Definition: bihash_8_8.h:34
ip6_address_t dst_address
Definition: ioam_cache.h:132
#define hash_mix64(a0, b0, c0)
Definition: hash.h:531
svmdb_client_t * c
u16 n_vectors
Definition: node.h:395
u32 pool_id
Definition: ioam_cache.h:129
format_function_t format_ip6_address
Definition: format.h:93
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
static void * ip6_ioam_find_hbh_option(ip6_hop_by_hop_header_t *hbh0, u8 option)
u32 timer_handle
Handle returned from tw_start_timer.
Definition: ioam_cache.h:144
8 octet key, 8 octet key value pair
Definition: bihash_8_8.h:31
signed int i32
Definition: types.h:77
u16 my_address_offset
Definition: ioam_cache.h:110
#define IP_FLOW_HASH_SRC_ADDR
Flow hash configuration.
Definition: lookup.h:61
void expired_cache_ts_timer_callback(u32 *expired_timers)
clib_bihash_8_8_t ioam_rewrite_cache_table
Definition: ioam_cache.h:184
u32 stop_timer_handle
Definition: ioam_cache.h:142
u32 pool_index
Definition: ioam_cache.h:130
void ioam_cache_ts_timer_node_enable(vlib_main_t *vm, u8 enable)
static u8 * format_ioam_cache_entry(u8 *s, va_list *args)
Definition: ioam_cache.h:486
#define IP_FLOW_HASH_DEFAULT
Default: 5-tuple without the "reverse" bit.
Definition: lookup.h:70
static void ioam_cache_ts_send(u32 thread_id, i32 pool_index)
Definition: ioam_cache.h:683
u32 flow_hash_config_t
A flow hash configuration is a mask of the flow hash options.
Definition: lookup.h:84
#define IOAM_E2E_CACHE_OPTION_RND
Definition: ioam_cache.h:283
struct _vlib_node_registration vlib_node_registration_t
static void ioam_cache_ts_timer_reset(ioam_cache_main_t *cm, ioam_cache_ts_entry_t *entry)
Definition: ioam_cache.h:568
u16 dst_port
Definition: ioam_cache.h:134
static int ioam_cache_ts_table_destroy(vlib_main_t *vm)
Definition: ioam_cache.h:603
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
static uword max_log2(uword x)
Definition: clib.h:191
vlib_main_t * vlib_main
Definition: ioam_cache.h:201
VLIB buffer representation.
Definition: buffer.h:102
u64 uword
Definition: types.h:112
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:244
u8 * format_time_interval(u8 *s, va_list *args)
Definition: std-formats.c:122
u32 buffer_index
Definition: ioam_cache.h:137
ip6_hop_by_hop_header_t * hbh
Definition: ioam_cache.h:138
Segment Routing data structures definitions.
#define HBH_OPTION_TYPE_SKIP_UNKNOWN
#define IP_FLOW_HASH_PROTO
Definition: lookup.h:63
static int ioam_cache_ts_entry_cleanup(u32 thread_id, u32 pool_index)
Definition: ioam_cache.h:629
u8 max_responses
Definition: ioam_cache.h:141
u16 src_port
Definition: ioam_cache.h:133
u32 id
Definition: udp.api:45
u16 dst_port
Definition: udp.api:42
u32 ip6_add_from_cache_hbh_node_index
Definition: ioam_cache.h:209
ioam_cache_main_t ioam_cache_main
Definition: ioam_cache.c:58
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
#define HBH_OPTION_TYPE_IOAM_E2E_CACHE_ID
Definition: ioam_cache.h:267
u8 * ioam_rewrite_string
Definition: ioam_cache.h:111
#define IOAM_E2E_ID_OPTION_RND
Definition: ioam_cache.h:281
u8 protocol
Definition: ipsec.api:96
ip6_address_t dst_address
Definition: ip6_packet.h:385
#define IOAM_CACHE_TS_TICK
Definition: ioam_cache.h:511
static u8 * ip6_sr_compute_rewrite_string_insert(ip6_address_t *sl)
SR rewrite string computation for SRH insertion (inline)
Definition: sr.h:289