pvti: Packet Vector Tunnel Interface

This plugin implements a PoC of UDP-based tunnel substrate whose aim is
to specifically provide higher MTU to the upper layers by chunking
the payload PDUs into smaller packets with full 5-tuple.

At the same time, if there are multiple small packets to
the same destination during the vector processing, they
are packed into "carrier" packets up to underlay MTU size.

It does assume a trustworthy underlying medium, thus for the
operation over Internet it requires the use of encryption layer
underneath.

Type: feature
Change-Id: I323958fa8de62584f6ed15643ea689568a9a62bc
Signed-off-by: Andrew Yourtchenko <ayourtch@gmail.com>

1 files changed, 257 insertions, 0 deletions

diff --git a/src/plugins/pvti/pvti.h b/src/plugins/pvti/pvti.h
new file mode 100644
index 00000000000..ac097c5ecca
--- /dev/null
+++ b/src/plugins/pvti/pvti.h
@@ -0,0 +1,257 @@
+/*
+ * pvti.h - skeleton vpp engine plug-in header file
+ *
+ * Copyright (c) 2024 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef __included_pvti_h__
+#define __included_pvti_h__
+
+#include <vnet/vnet.h>
+#include <vnet/ip/ip.h>
+#include <vnet/ethernet/ethernet.h>
+
+#include <vppinfra/hash.h>
+#include <vppinfra/error.h>
+
+#define VPP_MAX_THREADS (1 << 8)
+
+#define MAX_RX_STREAMS 256
+
+#define PVTI_ALIGN_BYTES 9
+
+typedef CLIB_PACKED (struct {
+  u32 seq;
+  u8 stream_index; // set to the cpu# on the sending side
+  u8 chunk_count;
+  u8 reass_chunk_count; // number of chunks in the front that are related to
+			// previously started buffer
+  // mandatory_flags_mask highlights which of the flags cause packet drop if
+  // not understood, and which of them can be just ignored.
+  u8 mandatory_flags_mask;
+  u8 flags_value;
+  u8 pad_bytes;
+  u8 pad[0];
+}) pvti_packet_header_t;
+
+typedef CLIB_PACKED (struct {
+  ip4_header_t ip4;
+  udp_header_t udp;
+  // not part of encap header pvti_packet_header_t pv;
+}) pvti_ip4_encap_header_t;
+
+typedef CLIB_PACKED (struct {
+  ip6_header_t ip6;
+  udp_header_t udp;
+  // not part of encap header pvti_packet_header_t pv;
+}) pvti_ip6_encap_header_t;
+
+typedef CLIB_PACKED (struct {
+  u16 total_chunk_length;
+  // More fragments: this chunk is not the last block fragment
+#define CHUNK_FLAGS_MF (1 << 0)
+  // More blocks: this block has chained blocks that follow
+#define CHUNK_FLAGS_MB (1 << 1)
+  u16 _pad0;
+  u32 _pad1;
+  u8 chunk_data[0];
+}) pvti_chunk_header_t;
+
+typedef struct
+{
+  // a buffer being built from the smaller packets
+  u32 bi0;
+
+  // how big can this buffer grow
+  u32 bi0_max_current_length;
+
+  // how many chunks are already in the buffer
+  u8 chunk_count;
+  // leading reassembly chunk count
+  u8 reass_chunk_count;
+
+  u32 current_tx_seq;
+} pvti_per_tx_stream_data_t;
+
+typedef struct
+{
+  /* The seq# that we last processed */
+  u32 last_rx_seq;
+
+  // a current buffer that is being reassembled
+  u32 rx_bi0;
+  // The root buffer, most of the times == rx_bi0 except in the case of chained
+  // buffers.
+  u32 rx_bi0_first;
+
+  // Next index for dispatch when the reassembly is done
+  u16 rx_next0;
+  // expected totall inner length for the packet
+  u16 rx_expected_inner_length;
+  u16 rx_received_inner_length;
+
+} pvti_per_rx_stream_data_t;
+
+typedef struct
+{
+  ip_address_t local_ip;
+  ip_address_t remote_ip;
+  u16 remote_port;
+  u16 local_port;
+  u16 underlay_mtu;
+  u32 underlay_fib_index;
+
+  u32 pvti_if_index;
+  bool deleted;
+  bool is_bo0_traced;
+
+  u32 bo0_max_current_length;
+
+  u8 chunk_count;
+  u8 reass_chunk_count;
+  u32 current_tx_seq;
+  vlib_buffer_t *bo0;
+
+} pvti_tx_peer_t;
+
+typedef struct
+{
+  ip_address_t local_ip;
+  ip_address_t remote_ip;
+  u16 remote_port;
+  u16 local_port;
+
+  pvti_per_rx_stream_data_t rx_streams[MAX_RX_STREAMS];
+
+  u32 pvti_if_index;
+  bool deleted;
+} pvti_rx_peer_t;
+
+typedef struct
+{
+  /* pool of destination-based structures which are used to build the packets
+   */
+  pvti_tx_peer_t *tx_peers;
+
+  /* vector of buffers to send */
+  u32 *pending_tx_buffers;
+  u16 *pending_tx_nexts;
+  /* pool of source-based structures for the remote peers' data tracking
+   */
+  pvti_rx_peer_t *rx_peers;
+
+  /* vector of buffers being decapsulated */
+  u32 *pending_rx_buffers;
+  u16 *pending_rx_nexts;
+
+} pvti_per_thread_data_t;
+
+typedef struct
+{
+  ip_address_t local_ip;
+  ip_address_t remote_ip;
+  u16 remote_port;
+  u16 local_port;
+  u16 underlay_mtu;
+  u32 underlay_fib_index;
+  bool peer_address_from_payload;
+  u64 created_at;
+
+  u32 sw_if_index;
+  u32 hw_if_index;
+
+  // per-stream data for TX
+  pvti_per_tx_stream_data_t tx_streams[256];
+  pvti_per_rx_stream_data_t rx_streams[256];
+
+} pvti_if_t;
+
+typedef struct
+{
+  /* API message ID base */
+  u16 msg_id_base;
+
+  /* have we initialized the data structures ? */
+  bool is_initialized;
+
+  /* interface pool */
+  pvti_if_t *if_pool;
+
+  /* if_index in the pool above by sw_if_index */
+  index_t *if_index_by_sw_if_index;
+
+  /* indices by port */
+  index_t **if_indices_by_port;
+
+  /* per-thread data, ip4[0] and ip6[1] */
+  pvti_per_thread_data_t *per_thread_data[2];
+
+  /* on/off switch for the periodic function */
+  u8 periodic_timer_enabled;
+  /* Node index, non-zero if the periodic process has been created */
+  u32 periodic_node_index;
+
+  /* graph node state */
+  uword *bm_ip4_bypass_enabled_by_sw_if;
+  uword *bm_ip6_bypass_enabled_by_sw_if;
+
+  /* convenience */
+  vlib_main_t *vlib_main;
+  vnet_main_t *vnet_main;
+  ethernet_main_t *ethernet_main;
+} pvti_main_t;
+
+extern pvti_main_t pvti_main;
+
+extern vlib_node_registration_t pvti_node;
+extern vlib_node_registration_t pvti4_input_node;
+extern vlib_node_registration_t pvti4_output_node;
+extern vlib_node_registration_t pvti6_input_node;
+extern vlib_node_registration_t pvti6_output_node;
+extern vlib_node_registration_t pvti_periodic_node;
+
+always_inline u8
+pvti_get_stream_index (int is_ip6)
+{
+  u32 thread_index = vlib_get_thread_index ();
+
+  ASSERT ((thread_index & 0xffffff80) == 0);
+
+  u8 stream_index = (thread_index & 0x7f) | (is_ip6 ? 0x80 : 0);
+  return stream_index;
+}
+
+/* attempt to get a new buffer */
+always_inline u32
+pvti_get_new_buffer (vlib_main_t *vm)
+{
+  u32 bi0 = INDEX_INVALID;
+  if (vlib_buffer_alloc (vm, &bi0, 1) != 1)
+    {
+      return INDEX_INVALID;
+    }
+  vlib_buffer_t *b0 = vlib_get_buffer (vm, bi0);
+  b0->current_data = 0;
+  b0->current_length = 0;
+  return bi0;
+}
+
+/* Periodic function events */
+#define PVTI_EVENT1			   1
+#define PVTI_EVENT2			   2
+#define PVTI_EVENT_PERIODIC_ENABLE_DISABLE 3
+
+void pvti_create_periodic_process (pvti_main_t *);
+void pvti_verify_initialized (pvti_main_t *pvm);
+
+#endif /* __included_pvti_h__ */