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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
15 #ifndef __included_ioam_cache_h__
16 #define __included_ioam_cache_h__
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>
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>
30 #include <ioam/analyse/ip6/ip6_ioam_analyse.h>
31 #include <vppinfra/tw_timer_16t_2w_512sl.h>
34 * This header contains routines for caching of ioam header and
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.
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.
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.
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
101 /** Required for pool_get_aligned */
102 CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
103 ip6_address_t src_address;
104 ip6_address_t dst_address;
109 ip6_address_t next_hop;
110 u16 my_address_offset;
111 u8 *ioam_rewrite_string;
112 } ioam_cache_entry_t;
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
127 /** Required for pool_get_aligned */
128 CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
131 ip6_address_t src_address;
132 ip6_address_t dst_address;
138 ip6_hop_by_hop_header_t *hbh; //pointer to hbh header in the buffer
140 u8 response_received;
142 u32 stop_timer_handle;
143 /** Handle returned from tw_start_timer */
145 /** entry should expire at this clock tick */
146 u32 expected_to_expire;
147 } ioam_cache_ts_entry_t;
150 * Per thread tunnel selection cache stats
156 } ioam_cache_ts_pool_stats_t;
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
163 #define IOAM_CACHE_TABLE_DEFAULT_HASH_NUM_BUCKETS (4 * 1024)
164 #define IOAM_CACHE_TABLE_DEFAULT_HASH_MEMORY_SIZE (2<<20)
168 /* API message ID base */
171 /* Pool of ioam_cache_buffer_t */
172 ioam_cache_entry_t *ioam_rewrite_pool;
174 /* For steering packets ioam cache entry is followed by
175 * SR header. This is the SR rewrite template */
176 u8 *sr_rewrite_template;
177 /* The current rewrite string being used */
179 u8 rewrite_pool_index_offset;
180 ip6_address_t sr_localsid_cache;
182 u64 lookup_table_nbuckets;
183 u64 lookup_table_size;
184 clib_bihash_8_8_t ioam_rewrite_cache_table;
186 /* M-Anycast: Pool of ioam_cache_ts_entry_t per thread */
187 ioam_cache_ts_entry_t **ioam_ts_pool;
188 ioam_cache_ts_pool_stats_t *ts_stats;
189 /** per thread single-wheel */
190 tw_timer_wheel_16t_2w_512sl_t *timer_wheels;
193 * Selection criteria: oneway delay: Server to M-Anycast
196 bool criteria_oneway;
197 u8 wait_for_responses;
198 ip6_address_t sr_localsid_ts;
201 vlib_main_t *vlib_main;
203 uword cache_hbh_slot;
205 u32 ip6_hbh_pop_node_index;
206 u32 error_node_index;
207 u32 cleanup_process_node_index;
209 u32 ip6_add_from_cache_hbh_node_index;
210 u32 ip6_reset_ts_hbh_node_index;
213 extern ioam_cache_main_t ioam_cache_main;
215 extern vlib_node_registration_t ioam_cache_node;
216 extern vlib_node_registration_t ioam_cache_ts_node;
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
228 ip6_compute_flow_hash_ext (const ip6_header_t * ip,
231 u16 dst_port, flow_hash_config_t flow_hash_config)
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;
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;
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;
249 t1 = (flow_hash_config & IP_FLOW_HASH_SRC_PORT) ? t1 : 0;
250 t2 = (flow_hash_config & IP_FLOW_HASH_DST_PORT) ? t2 : 0;
252 c = (flow_hash_config & IP_FLOW_HASH_REVERSE_SRC_DST) ?
253 ((t1 << 16) | t2) : ((t2 << 16) | t1);
255 hash_mix64 (a, b, c);
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
266 #define HBH_OPTION_TYPE_IOAM_EDGE_TO_EDGE_ID 30
267 #define HBH_OPTION_TYPE_IOAM_E2E_CACHE_ID 31
269 typedef CLIB_PACKED (struct
271 ip6_hop_by_hop_option_t hdr; u8 e2e_type; u8 reserved[5];
273 }) ioam_e2e_id_option_t;
275 typedef CLIB_PACKED (struct
277 ip6_hop_by_hop_option_t hdr; u8 e2e_type; u8 pool_id;
279 }) ioam_e2e_cache_option_t;
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)
287 ioam_e2e_id_rewrite_handler (ioam_e2e_id_option_t * e2e_option,
288 ip6_address_t * address)
290 e2e_option->id.as_u64[0] = address->as_u64[0];
291 e2e_option->id.as_u64[1] = address->as_u64[1];
295 /* Following functions are for the caching of ioam header
296 * to enable reattaching it for a complete request-response
297 * message exchange */
299 ioam_cache_entry_free (ioam_cache_entry_t * entry)
301 ioam_cache_main_t *cm = &ioam_cache_main;
304 vec_free (entry->ioam_rewrite_string);
305 clib_memset (entry, 0, sizeof (*entry));
306 pool_put (cm->ioam_rewrite_pool, entry);
310 inline static ioam_cache_entry_t *
311 ioam_cache_entry_cleanup (u32 pool_index)
313 ioam_cache_main_t *cm = &ioam_cache_main;
314 ioam_cache_entry_t *entry = 0;
316 entry = pool_elt_at_index (cm->ioam_rewrite_pool, pool_index);
317 ioam_cache_entry_free (entry);
321 inline static ioam_cache_entry_t *
322 ioam_cache_lookup (ip6_header_t * ip0, u16 src_port, u16 dst_port, u32 seq_no)
324 ioam_cache_main_t *cm = &ioam_cache_main;
325 u32 flow_hash = ip6_compute_flow_hash_ext (ip0, ip0->protocol,
327 IP_FLOW_HASH_DEFAULT |
328 IP_FLOW_HASH_REVERSE_SRC_DST);
329 clib_bihash_kv_8_8_t kv, value;
331 kv.key = (u64) flow_hash << 32 | seq_no;
336 if (clib_bihash_search_8_8 (&cm->ioam_rewrite_cache_table, &kv, &value) >=
339 ioam_cache_entry_t *entry = 0;
341 entry = pool_elt_at_index (cm->ioam_rewrite_pool, value.value);
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)
348 /* If lookup is successful remove it from the hash */
349 clib_bihash_add_del_8_8 (&cm->ioam_rewrite_cache_table, &kv, 0);
360 * Caches ioam hbh header
361 * Extends the hbh header with option to contain IP6 address of the node
365 ioam_cache_add (vlib_buffer_t * b0,
368 u16 dst_port, ip6_hop_by_hop_header_t * hbh0, u32 seq_no)
370 ioam_cache_main_t *cm = &ioam_cache_main;
371 ioam_cache_entry_t *entry = 0;
372 u32 rewrite_len = 0, e2e_id_offset = 0;
374 ioam_e2e_id_option_t *e2e = 0;
376 pool_get_aligned (cm->ioam_rewrite_pool, entry, CLIB_CACHE_LINE_BYTES);
377 clib_memset (entry, 0, sizeof (*entry));
378 pool_index = entry - cm->ioam_rewrite_pool;
380 clib_memcpy_fast (entry->dst_address.as_u64, ip0->dst_address.as_u64,
381 sizeof (ip6_address_t));
382 clib_memcpy_fast (entry->src_address.as_u64, ip0->src_address.as_u64,
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);
389 e2e = ip6_ioam_find_hbh_option (hbh0, HBH_OPTION_TYPE_IOAM_EDGE_TO_EDGE_ID);
392 entry->next_hop.as_u64[0] = e2e->id.as_u64[0];
393 entry->next_hop.as_u64[1] = e2e->id.as_u64[1];
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);
402 hbh0 = (ip6_hop_by_hop_header_t *) entry->ioam_rewrite_string;
404 /* suffix rewrite string with e2e ID option */
405 e2e = (ioam_e2e_id_option_t *) (entry->ioam_rewrite_string + e2e_id_offset);
406 ioam_e2e_id_rewrite_handler (e2e, &cm->sr_localsid_cache);
407 entry->my_address_offset = (u8 *) (&e2e->id) - (u8 *) hbh0;
409 /* add it to hash, replacing and freeing any collision for now */
411 ip6_compute_flow_hash_ext (ip0, hbh0->protocol, src_port, dst_port,
412 IP_FLOW_HASH_DEFAULT);
413 clib_bihash_kv_8_8_t kv, value;
414 kv.key = (u64) flow_hash << 32 | seq_no;
416 if (clib_bihash_search_8_8 (&cm->ioam_rewrite_cache_table, &kv, &value) >=
420 ioam_cache_entry_cleanup (value.value);
422 kv.value = pool_index;
423 clib_bihash_add_del_8_8 (&cm->ioam_rewrite_cache_table, &kv, 1);
427 /* Creates SR rewrite string
428 * This is appended with ioam header on the server facing
430 * This SR header is necessary to attract packets towards
431 * selected Anycast server.
434 ioam_cache_sr_rewrite_template_create (void)
436 ioam_cache_main_t *cm = &ioam_cache_main;
437 ip6_address_t *segments = 0;
438 ip6_address_t *this_seg = 0;
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));
444 cm->sr_rewrite_template = ip6_sr_compute_rewrite_string_insert (segments);
449 ioam_cache_table_init (vlib_main_t * vm)
451 ioam_cache_main_t *cm = &ioam_cache_main;
453 pool_alloc_aligned (cm->ioam_rewrite_pool,
454 MAX_CACHE_ENTRIES, CLIB_CACHE_LINE_BYTES);
455 cm->lookup_table_nbuckets = IOAM_CACHE_TABLE_DEFAULT_HASH_NUM_BUCKETS;
456 cm->lookup_table_nbuckets = 1 << max_log2 (cm->lookup_table_nbuckets);
457 cm->lookup_table_size = IOAM_CACHE_TABLE_DEFAULT_HASH_MEMORY_SIZE;
459 clib_bihash_init_8_8 (&cm->ioam_rewrite_cache_table,
460 "ioam rewrite cache table",
461 cm->lookup_table_nbuckets, cm->lookup_table_size);
462 /* Create SR rewrite template */
463 ioam_cache_sr_rewrite_template_create ();
468 ioam_cache_table_destroy (vlib_main_t * vm)
470 ioam_cache_main_t *cm = &ioam_cache_main;
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)
476 ioam_cache_entry_free (entry);
478 pool_free (cm->ioam_rewrite_pool);
479 cm->ioam_rewrite_pool = 0;
480 vec_free (cm->sr_rewrite_template);
481 cm->sr_rewrite_template = 0;
486 format_ioam_cache_entry (u8 * s, va_list * args)
488 ioam_cache_entry_t *e = va_arg (*args, ioam_cache_entry_t *);
489 ioam_cache_main_t *cm = &ioam_cache_main;
490 int rewrite_len = vec_len (e->ioam_rewrite_string);
492 s = format (s, "%d: %U:%d to %U:%d seq_no %lu\n",
493 (e - cm->ioam_rewrite_pool),
494 format_ip6_address, &e->src_address,
496 format_ip6_address, &e->dst_address, e->dst_port, e->seq_no);
500 s = format (s, " %U",
501 format_ip6_hop_by_hop_ext_hdr,
502 (ip6_hop_by_hop_header_t *) e->ioam_rewrite_string,
508 void ioam_cache_ts_timer_node_enable (vlib_main_t * vm, u8 enable);
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)
517 void expired_cache_ts_timer_callback (u32 * expired_timers);
520 * Following functions are to manage M-Anycast server selection
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
528 ioam_cache_ts_table_init (vlib_main_t * vm)
530 ioam_cache_main_t *cm = &ioam_cache_main;
531 int no_of_threads = vec_len (vlib_worker_threads);
534 vec_validate_aligned (cm->ioam_ts_pool, no_of_threads - 1,
535 CLIB_CACHE_LINE_BYTES);
536 vec_validate_aligned (cm->ts_stats, no_of_threads - 1,
537 CLIB_CACHE_LINE_BYTES);
538 vec_validate (cm->timer_wheels, no_of_threads - 1);
539 cm->lookup_table_nbuckets = IOAM_CACHE_TABLE_DEFAULT_HASH_NUM_BUCKETS;
540 cm->lookup_table_nbuckets = 1 << max_log2 (cm->lookup_table_nbuckets);
541 cm->lookup_table_size = IOAM_CACHE_TABLE_DEFAULT_HASH_MEMORY_SIZE;
542 for (i = 0; i < no_of_threads; i++)
544 pool_alloc_aligned (cm->ioam_ts_pool[i],
545 MAX_CACHE_TS_ENTRIES, CLIB_CACHE_LINE_BYTES);
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],
548 expired_cache_ts_timer_callback,
550 /* timer period 100ms */ ,
552 cm->timer_wheels[i].last_run_time = vlib_time_now (vm);
554 ioam_cache_ts_timer_node_enable (vm, 1);
559 ioam_cache_ts_timer_set (ioam_cache_main_t * cm,
560 ioam_cache_ts_entry_t * entry, u32 interval)
563 = tw_timer_start_16t_2w_512sl (&cm->timer_wheels[entry->pool_id],
564 entry->pool_index, 1, interval);
568 ioam_cache_ts_timer_reset (ioam_cache_main_t * cm,
569 ioam_cache_ts_entry_t * entry)
571 tw_timer_stop_16t_2w_512sl (&cm->timer_wheels[entry->pool_id],
572 entry->timer_handle);
573 entry->timer_handle = TIMER_HANDLE_INVALID;
577 ioam_cache_ts_entry_free (u32 thread_id,
578 ioam_cache_ts_entry_t * entry, u32 node_index)
580 ioam_cache_main_t *cm = &ioam_cache_main;
581 vlib_main_t *vm = cm->vlib_main;
582 vlib_frame_t *nf = 0;
589 nf = vlib_get_frame_to_node (vm, node_index);
591 to_next = vlib_frame_vector_args (nf);
593 to_next[0] = entry->buffer_index;
594 vlib_put_frame_to_node (vm, node_index, nf);
596 pool_put (cm->ioam_ts_pool[thread_id], entry);
597 cm->ts_stats[thread_id].inuse--;
598 clib_memset (entry, 0, sizeof (*entry));
603 ioam_cache_ts_table_destroy (vlib_main_t * vm)
605 ioam_cache_main_t *cm = &ioam_cache_main;
606 ioam_cache_ts_entry_t *entry = 0;
607 int no_of_threads = vec_len (vlib_worker_threads);
610 /* free pool and hash table */
611 for (i = 0; i < no_of_threads; i++)
613 pool_foreach (entry, cm->ioam_ts_pool[i])
615 ioam_cache_ts_entry_free (i, entry, cm->error_node_index);
617 pool_free (cm->ioam_ts_pool[i]);
618 cm->ioam_ts_pool = 0;
619 tw_timer_wheel_free_16t_2w_512sl (&cm->timer_wheels[i]);
621 vec_free (cm->ioam_ts_pool);
626 ioam_cache_ts_entry_cleanup (u32 thread_id, u32 pool_index)
628 ioam_cache_main_t *cm = &ioam_cache_main;
629 ioam_cache_ts_entry_t *entry = 0;
631 entry = pool_elt_at_index (cm->ioam_ts_pool[thread_id], pool_index);
632 ioam_cache_ts_entry_free (thread_id, entry, cm->error_node_index);
637 * Caches buffer for ioam SR tunnel select for Anycast service
640 ioam_cache_ts_add (ip6_header_t * ip0,
644 u8 max_responses, u64 now, u32 thread_id, u32 * pool_index)
646 ioam_cache_main_t *cm = &ioam_cache_main;
647 ioam_cache_ts_entry_t *entry = 0;
649 if (cm->ts_stats[thread_id].inuse == MAX_CACHE_TS_ENTRIES)
651 cm->ts_stats[thread_id].add_failed++;
655 pool_get_aligned (cm->ioam_ts_pool[thread_id], entry,
656 CLIB_CACHE_LINE_BYTES);
657 clib_memset (entry, 0, sizeof (*entry));
658 *pool_index = entry - cm->ioam_ts_pool[thread_id];
660 clib_memcpy_fast (entry->dst_address.as_u64, ip0->dst_address.as_u64,
661 sizeof (ip6_address_t));
662 clib_memcpy_fast (entry->src_address.as_u64, ip0->src_address.as_u64,
663 sizeof (ip6_address_t));
664 entry->src_port = src_port;
665 entry->dst_port = dst_port;
666 entry->seq_no = seq_no;
667 entry->response_received = 0;
668 entry->max_responses = max_responses;
669 entry->created_at = now;
671 entry->buffer_index = 0;
672 entry->pool_id = thread_id;
673 entry->pool_index = *pool_index;
674 ioam_cache_ts_timer_set (cm, entry, IOAM_CACHE_TS_TIMEOUT);
675 cm->ts_stats[thread_id].inuse++;
680 ioam_cache_ts_send (u32 thread_id, i32 pool_index)
682 ioam_cache_main_t *cm = &ioam_cache_main;
683 ioam_cache_ts_entry_t *entry = 0;
685 entry = pool_elt_at_index (cm->ioam_ts_pool[thread_id], pool_index);
686 if (!pool_is_free (cm->ioam_ts_pool[thread_id], entry) && entry)
688 /* send and free pool entry */
689 ioam_cache_ts_entry_free (thread_id, entry, cm->ip6_hbh_pop_node_index);
694 ioam_cache_ts_check_and_send (u32 thread_id, i32 pool_index)
696 ioam_cache_main_t *cm = &ioam_cache_main;
697 ioam_cache_ts_entry_t *entry = 0;
698 entry = pool_elt_at_index (cm->ioam_ts_pool[thread_id], pool_index);
699 if (entry && entry->hbh)
701 if (entry->response_received == entry->max_responses ||
702 entry->created_at + IOAM_CACHE_TS_TIMEOUT <=
703 vlib_time_now (cm->vlib_main))
705 ioam_cache_ts_timer_reset (cm, entry);
706 ioam_cache_ts_send (thread_id, pool_index);
712 ioam_cache_ts_update (u32 thread_id,
714 u32 buffer_index, ip6_hop_by_hop_header_t * hbh)
716 ioam_cache_main_t *cm = &ioam_cache_main;
717 ioam_cache_ts_entry_t *entry = 0;
718 vlib_main_t *vm = cm->vlib_main;
719 vlib_frame_t *nf = 0;
722 entry = pool_elt_at_index (cm->ioam_ts_pool[thread_id], pool_index);
723 if (!pool_is_free (cm->ioam_ts_pool[thread_id], entry) && entry)
725 /* drop existing buffer */
728 nf = vlib_get_frame_to_node (vm, cm->error_node_index);
730 to_next = vlib_frame_vector_args (nf);
732 to_next[0] = entry->buffer_index;
733 vlib_put_frame_to_node (vm, cm->error_node_index, nf);
736 entry->buffer_index = buffer_index;
739 ioam_cache_ts_check_and_send (thread_id, pool_index);
746 * looks up the entry based on the e2e option pool index
747 * result = 0 found the entry
748 * result < 0 indicates failture to find an entry
751 ioam_cache_ts_lookup (ip6_header_t * ip0,
756 ip6_hop_by_hop_header_t ** hbh,
757 u32 * pool_index, u8 * thread_id, u8 response_seen)
759 ioam_cache_main_t *cm = &ioam_cache_main;
760 ip6_hop_by_hop_header_t *hbh0 = 0;
761 ioam_e2e_cache_option_t *e2e = 0;
763 hbh0 = (ip6_hop_by_hop_header_t *) (ip0 + 1);
765 (ioam_e2e_cache_option_t *) ((u8 *) hbh0 + cm->rewrite_pool_index_offset);
766 if ((u8 *) e2e < ((u8 *) hbh0 + ((hbh0->length + 1) << 3))
767 && e2e->hdr.type == HBH_OPTION_TYPE_IOAM_E2E_CACHE_ID)
769 ioam_cache_ts_entry_t *entry = 0;
770 *pool_index = e2e->pool_index;
771 *thread_id = e2e->pool_id;
772 entry = pool_elt_at_index (cm->ioam_ts_pool[*thread_id], *pool_index);
775 ip6_address_compare (&ip0->src_address, &entry->dst_address) == 0 &&
776 ip6_address_compare (&ip0->dst_address, &entry->src_address) == 0 &&
777 entry->src_port == dst_port &&
778 entry->dst_port == src_port && entry->seq_no == seq_no)
781 entry->response_received += response_seen;
793 format_ioam_cache_ts_entry (u8 * s, va_list * args)
795 ioam_cache_ts_entry_t *e = va_arg (*args, ioam_cache_ts_entry_t *);
796 u32 thread_id = va_arg (*args, u32);
797 ioam_cache_main_t *cm = &ioam_cache_main;
798 ioam_e2e_id_option_t *e2e = 0;
799 vlib_main_t *vm = cm->vlib_main;
800 clib_time_t *ct = &vm->clib_time;
808 ip6_ioam_find_hbh_option (e->hbh,
809 HBH_OPTION_TYPE_IOAM_EDGE_TO_EDGE_ID);
813 "%d: %U:%d to %U:%d seq_no %u buffer %u %U \n\t\tCreated at %U Received %d\n",
814 (e - cm->ioam_ts_pool[thread_id]), format_ip6_address,
815 &e->src_address, e->src_port, format_ip6_address,
816 &e->dst_address, e->dst_port, e->seq_no, e->buffer_index,
817 format_ip6_address, e2e ? &e2e->id : 0, format_time_interval,
820 vm->cpu_time_main_loop_start) * ct->seconds_per_clock,
821 e->response_received);
827 "%d: %U:%d to %U:%d seq_no %u Buffer %u \n\t\tCreated at %U Received %d\n",
828 (e - cm->ioam_ts_pool[thread_id]), format_ip6_address,
829 &e->src_address, e->src_port, format_ip6_address,
830 &e->dst_address, e->dst_port, e->seq_no, e->buffer_index,
831 format_time_interval, "h:m:s:u",
833 vm->cpu_time_main_loop_start) * ct->seconds_per_clock,
834 e->response_received);
842 * Get extended rewrite string for iOAM data in v6
843 * This makes space for an e2e options to carry cache pool info
844 * and manycast server address.
845 * It set the rewrite string per configs in ioam ip6 + new option
846 * for cache along with offset to the option to populate cache
850 ip6_ioam_ts_cache_set_rewrite (void)
852 ip6_hop_by_hop_ioam_main_t *hm = &ip6_hop_by_hop_ioam_main;
853 ioam_cache_main_t *cm = &ioam_cache_main;
854 ip6_hop_by_hop_header_t *hbh;
856 ioam_e2e_cache_option_t *e2e = 0;
857 ioam_e2e_id_option_t *e2e_id = 0;
859 vec_free (cm->rewrite);
860 ip6_ioam_set_rewrite (&(cm->rewrite), hm->has_trace_option,
861 hm->has_pot_option, hm->has_seqno_option);
862 hbh = (ip6_hop_by_hop_header_t *) cm->rewrite;
863 rewrite_len = ((hbh->length + 1) << 3);
864 vec_validate (cm->rewrite,
865 rewrite_len - 1 + IOAM_E2E_CACHE_OPTION_RND +
866 IOAM_E2E_ID_OPTION_RND);
867 hbh = (ip6_hop_by_hop_header_t *) cm->rewrite;
868 /* setup e2e id option to insert pool id and index of the node caching it */
869 hbh->length += IOAM_E2E_CACHE_HBH_EXT_LEN + IOAM_E2E_ID_HBH_EXT_LEN;
870 cm->rewrite_pool_index_offset = rewrite_len;
871 e2e = (ioam_e2e_cache_option_t *) (cm->rewrite + rewrite_len);
872 e2e->hdr.type = HBH_OPTION_TYPE_IOAM_E2E_CACHE_ID
873 | HBH_OPTION_TYPE_SKIP_UNKNOWN;
874 e2e->hdr.length = sizeof (ioam_e2e_cache_option_t) -
875 sizeof (ip6_hop_by_hop_option_t);
878 (ioam_e2e_id_option_t *) ((u8 *) e2e + sizeof (ioam_e2e_cache_option_t));
880 HBH_OPTION_TYPE_IOAM_EDGE_TO_EDGE_ID | HBH_OPTION_TYPE_SKIP_UNKNOWN;
882 sizeof (ioam_e2e_id_option_t) - sizeof (ip6_hop_by_hop_option_t);
883 e2e_id->e2e_type = 1;
889 ip6_ioam_ts_cache_cleanup_rewrite (void)
891 ioam_cache_main_t *cm = &ioam_cache_main;
893 vec_free (cm->rewrite);
895 cm->rewrite_pool_index_offset = 0;
898 #endif /* __included_ioam_cache_h__ */
901 * fd.io coding-style-patch-verification: ON
904 * eval: (c-set-style "gnu")