#include "parse_utils.h"
#include "cfgfile.h"
#include "prox_shared.h"
+#include "prox_compat.h"
#if RTE_VERSION < RTE_VERSION_NUM(1,8,0,0)
#define IPPROTO_IPIP IPPROTO_IPV4
struct ipv6_tun_dest {
struct ipv6_addr dst_addr;
- struct ether_addr dst_mac;
+ prox_rte_ether_addr dst_mac;
};
typedef enum ipv6_tun_dir_t {
struct task_ipv6_tun_base {
struct task_base base;
- struct ether_addr src_mac;
+ prox_rte_ether_addr src_mac;
uint8_t core_nb;
uint64_t keys[64];
struct rte_mbuf* fake_packets[64];
struct task_ipv6_decap {
struct task_ipv6_tun_base base;
- struct ether_addr dst_mac;
+ prox_rte_ether_addr dst_mac;
};
struct task_ipv6_encap {
int ret = lua_to_ip6_tun_binding(prox_lua(), GLOBAL, targ->tun_bindings, socket_id, &table);
PROX_PANIC(ret, "Failed to read tun_bindings config:\n %s\n", get_lua_to_errors());
- struct rte_table_hash_key8_ext_params table_hash_params = {
- .n_entries = (table->num_binding_entries * 4),
- .n_entries_ext = (table->num_binding_entries * 2) >> 1,
- .f_hash = hash_crc32,
+ static char hash_name[30];
+ sprintf(hash_name, "ipv6_tunnel_hash_table_%03d", targ->lconf->id);
+
+ struct prox_rte_table_params table_hash_params = {
+ .name = hash_name,
+ .key_size = 8,
+ .n_keys = (table->num_binding_entries * 4),
+ .n_buckets = (table->num_binding_entries * 2) >> 1,
+ .f_hash = (rte_table_hash_op_hash)hash_crc32,
.seed = 0,
- .signature_offset = HASH_METADATA_OFFSET(8), // Ignored for dosig tables
.key_offset = HASH_METADATA_OFFSET(0),
+ .key_mask = NULL
};
plogx_info("IPv6 Tunnel allocating lookup table on socket %d\n", socket_id);
- ptask->lookup_table = rte_table_hash_key8_ext_dosig_ops.
- f_create(&table_hash_params, socket_id, sizeof(struct ipv6_tun_dest));
+ ptask->lookup_table = prox_rte_table_create(&table_hash_params, socket_id, sizeof(struct ipv6_tun_dest));
PROX_PANIC(ptask->lookup_table == NULL, "Error creating IPv6 Tunnel lookup table");
for (unsigned idx = 0; idx < table->num_binding_entries; idx++) {
struct ipv6_tun_binding_entry* entry = &table->entry[idx];
uint64_t key = MAKE_KEY_FROM_FIELDS(rte_cpu_to_be_32(entry->public_ipv4), entry->public_port, ptask->lookup_port_mask);
rte_memcpy(&data.dst_addr, &entry->endpoint_addr, sizeof(struct ipv6_addr));
- rte_memcpy(&data.dst_mac, &entry->next_hop_mac, sizeof(struct ether_addr));
+ rte_memcpy(&data.dst_mac, &entry->next_hop_mac, sizeof(prox_rte_ether_addr));
- int ret = rte_table_hash_key8_ext_dosig_ops.f_add(ptask->lookup_table, &key, &data, &key_found, &entry_in_hash);
+ int ret = prox_rte_table_key8_add(ptask->lookup_table, &key, &data, &key_found, &entry_in_hash);
PROX_PANIC(ret, "Error adding entry (%d) to binding lookup table", idx);
PROX_PANIC(key_found, "key_found!!! for idx=%d\n", idx);
struct prox_port_cfg *port = find_reachable_port(targ);
if (port) {
- tun_base->offload_crc = port->capabilities.tx_offload_cksum;
+ tun_base->offload_crc = port->requested_tx_offload & (DEV_TX_OFFLOAD_IPV4_CKSUM | DEV_TX_OFFLOAD_UDP_CKSUM);
}
}
static inline uint8_t handle_ipv6_decap(struct task_ipv6_decap* ptask, struct rte_mbuf* rx_mbuf, struct ipv6_tun_dest* tun_dest);
static inline uint8_t handle_ipv6_encap(struct task_ipv6_encap* ptask, struct rte_mbuf* rx_mbuf, struct ipv6_tun_dest* tun_dest);
-static inline int extract_key_fields( __attribute__((unused)) struct task_ipv6_tun_base* ptask, struct ipv4_hdr* pip4, ipv6_tun_dir_t dir, uint32_t* pAddr, uint16_t* pPort)
+static inline int extract_key_fields( __attribute__((unused)) struct task_ipv6_tun_base* ptask, prox_rte_ipv4_hdr* pip4, ipv6_tun_dir_t dir, uint32_t* pAddr, uint16_t* pPort)
{
*pAddr = (dir == TUNNEL_DIR_DECAP) ? pip4->src_addr : pip4->dst_addr;
if (pip4->next_proto_id == IPPROTO_UDP) {
- struct udp_hdr* pudp = (struct udp_hdr *)(pip4 + 1);
+ prox_rte_udp_hdr* pudp = (prox_rte_udp_hdr *)(pip4 + 1);
*pPort = rte_be_to_cpu_16((dir == TUNNEL_DIR_DECAP) ? pudp->src_port : pudp->dst_port);
}
else if (pip4->next_proto_id == IPPROTO_TCP) {
- struct tcp_hdr* ptcp = (struct tcp_hdr *)(pip4 + 1);
+ prox_rte_tcp_hdr* ptcp = (prox_rte_tcp_hdr *)(pip4 + 1);
*pPort = rte_be_to_cpu_16((dir == TUNNEL_DIR_DECAP) ? ptcp->src_port : ptcp->dst_port);
}
else {
return 0;
}
-static inline void extract_key(struct task_ipv6_tun_base* ptask, struct ipv4_hdr* pip4, ipv6_tun_dir_t dir, uint64_t* pkey)
+static inline void extract_key(struct task_ipv6_tun_base* ptask, prox_rte_ipv4_hdr* pip4, ipv6_tun_dir_t dir, uint64_t* pkey)
{
uint32_t lookup_addr;
uint16_t lookup_port;
*pkey = MAKE_KEY_FROM_FIELDS(lookup_addr, lookup_port, ptask->lookup_port_mask);
}
-static inline struct ipv4_hdr* get_ipv4_decap(struct rte_mbuf *mbuf)
+static inline prox_rte_ipv4_hdr* get_ipv4_decap(struct rte_mbuf *mbuf)
{
- struct ether_hdr* peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
- struct ipv6_hdr* pip6 = (struct ipv6_hdr *)(peth + 1);
- struct ipv4_hdr* pip4 = (struct ipv4_hdr*) (pip6 + 1); // TODO - Skip Option headers
+ prox_rte_ether_hdr* peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
+ prox_rte_ipv6_hdr* pip6 = (prox_rte_ipv6_hdr *)(peth + 1);
+ prox_rte_ipv4_hdr* pip4 = (prox_rte_ipv4_hdr*) (pip6 + 1); // TODO - Skip Option headers
return pip4;
}
-static inline struct ipv4_hdr* get_ipv4_encap(struct rte_mbuf *mbuf)
+static inline prox_rte_ipv4_hdr* get_ipv4_encap(struct rte_mbuf *mbuf)
{
- struct ether_hdr* peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
- struct ipv4_hdr* pip4 = (struct ipv4_hdr *)(peth + 1);
+ prox_rte_ether_hdr* peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
+ prox_rte_ipv4_hdr* pip4 = (prox_rte_ipv4_hdr *)(peth + 1);
return pip4;
}
uint16_t lookup_port;
uint64_t key;
- struct ipv4_hdr* pip4 = (dir == TUNNEL_DIR_DECAP) ? get_ipv4_decap(mbuf) : get_ipv4_encap(mbuf);
+ prox_rte_ipv4_hdr* pip4 = (dir == TUNNEL_DIR_DECAP) ? get_ipv4_decap(mbuf) : get_ipv4_encap(mbuf);
extract_key_fields(ptask, pip4, dir, &lookup_addr, &lookup_port);
extract_key(ptask, pip4, dir, &key);
// Lookup to verify packets are valid for their respective tunnels (their sending lwB4)
extract_key_decap_bulk(&task->base, mbufs, n_pkts);
- rte_table_hash_key8_ext_dosig_ops.f_lookup(task->base.lookup_table, task->base.fake_packets, pkts_mask, &lookup_hit_mask, (void**)entries);
+ prox_rte_table_key8_lookup(task->base.lookup_table, task->base.fake_packets, pkts_mask, &lookup_hit_mask, (void**)entries);
if (likely(lookup_hit_mask == pkts_mask)) {
for (uint16_t j = 0; j < n_pkts; ++j) {
prefetch_first(mbufs, n_pkts);
extract_key_encap_bulk(&task->base, mbufs, n_pkts);
- rte_table_hash_key8_ext_dosig_ops.f_lookup(task->base.lookup_table, task->base.fake_packets, pkts_mask, &lookup_hit_mask, (void**)entries);
+ prox_rte_table_key8_lookup(task->base.lookup_table, task->base.fake_packets, pkts_mask, &lookup_hit_mask, (void**)entries);
if (likely(lookup_hit_mask == pkts_mask)) {
for (uint16_t j = 0; j < n_pkts; ++j) {
static inline uint8_t handle_ipv6_decap(struct task_ipv6_decap* ptask, struct rte_mbuf* rx_mbuf, __attribute__((unused)) struct ipv6_tun_dest* tun_dest)
{
- struct ether_hdr* peth = rte_pktmbuf_mtod(rx_mbuf, struct ether_hdr *);
+ prox_rte_ether_hdr* peth = rte_pktmbuf_mtod(rx_mbuf, prox_rte_ether_hdr *);
struct task_ipv6_tun_base* tun_base = (struct task_ipv6_tun_base*)ptask;
- struct ipv4_hdr* pip4 = NULL;
+ prox_rte_ipv4_hdr* pip4 = NULL;
if (unlikely(peth->ether_type != ETYPE_IPv6)) {
plog_warn("Received non IPv6 packet on ipv6 tunnel port\n");
return OUT_DISCARD;
}
- struct ipv6_hdr* pip6 = (struct ipv6_hdr *)(peth + 1);
- int ipv6_hdr_len = sizeof(struct ipv6_hdr);
+ prox_rte_ipv6_hdr* pip6 = (prox_rte_ipv6_hdr *)(peth + 1);
+ int ipv6_hdr_len = sizeof(prox_rte_ipv6_hdr);
// TODO - Skip over any IPv6 Extension Header:
// If pip6->next_header is in (0, 43, 44, 50, 51, 60, 135), skip ahead pip->hdr_ext_len
// Discard IPv6 encapsulation
rte_pktmbuf_adj(rx_mbuf, ipv6_hdr_len);
- peth = rte_pktmbuf_mtod(rx_mbuf, struct ether_hdr *);
- pip4 = (struct ipv4_hdr *)(peth + 1);
+ peth = rte_pktmbuf_mtod(rx_mbuf, prox_rte_ether_hdr *);
+ pip4 = (prox_rte_ipv4_hdr *)(peth + 1);
// Restore Ethernet header
- ether_addr_copy(&ptask->base.src_mac, &peth->s_addr);
- ether_addr_copy(&ptask->dst_mac, &peth->d_addr);
+ prox_rte_ether_addr_copy(&ptask->base.src_mac, &peth->s_addr);
+ prox_rte_ether_addr_copy(&ptask->dst_mac, &peth->d_addr);
peth->ether_type = ETYPE_IPv4;
#ifdef GEN_DECAP_IPV6_TO_IPV4_CKSUM
// generate an IP checksum for ipv4 packet
if (tun_base->runtime_flags & TASK_TX_CRC) {
- prox_ip_cksum(rx_mbuf, pip4, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), ptask->base.offload_crc);
+ prox_ip_cksum(rx_mbuf, pip4, sizeof(prox_rte_ether_hdr), sizeof(prox_rte_ipv4_hdr), ptask->base.offload_crc);
}
#endif
{
//plog_info("Found tunnel endpoint:"IPv6_BYTES_FMT" ("MAC_BYTES_FMT")\n", IPv6_BYTES(tun_dest->dst_addr), MAC_BYTES(tun_dest->dst_mac.addr_bytes));
- struct ether_hdr* peth = (struct ether_hdr *)(rte_pktmbuf_mtod(rx_mbuf, struct ether_hdr *));
- struct ipv4_hdr* pip4 = (struct ipv4_hdr *)(peth + 1);
+ prox_rte_ether_hdr* peth = (prox_rte_ether_hdr *)(rte_pktmbuf_mtod(rx_mbuf, prox_rte_ether_hdr *));
+ prox_rte_ipv4_hdr* pip4 = (prox_rte_ipv4_hdr *)(peth + 1);
uint16_t ipv4_length = rte_be_to_cpu_16(pip4->total_length);
struct task_ipv6_tun_base* tun_base = (struct task_ipv6_tun_base*)ptask;
pip4->hdr_checksum = 0;
// Remove padding if any (we don't want to encapsulate garbage at end of IPv4 packet)
- int padding = rte_pktmbuf_pkt_len(rx_mbuf) - (ipv4_length + sizeof(struct ether_hdr));
+ int padding = rte_pktmbuf_pkt_len(rx_mbuf) - (ipv4_length + sizeof(prox_rte_ether_hdr));
if (unlikely(padding > 0)) {
rte_pktmbuf_trim(rx_mbuf, padding);
}
// Encapsulate
- const int extra_space = sizeof(struct ipv6_hdr);
- peth = (struct ether_hdr *)rte_pktmbuf_prepend(rx_mbuf, extra_space);
+ const int extra_space = sizeof(prox_rte_ipv6_hdr);
+ peth = (prox_rte_ether_hdr *)rte_pktmbuf_prepend(rx_mbuf, extra_space);
// Ethernet Header
- ether_addr_copy(&ptask->base.src_mac, &peth->s_addr);
- ether_addr_copy(&tun_dest->dst_mac, &peth->d_addr);
+ prox_rte_ether_addr_copy(&ptask->base.src_mac, &peth->s_addr);
+ prox_rte_ether_addr_copy(&tun_dest->dst_mac, &peth->d_addr);
peth->ether_type = ETYPE_IPv6;
// Set up IPv6 Header
- struct ipv6_hdr* pip6 = (struct ipv6_hdr *)(peth + 1);
+ prox_rte_ipv6_hdr* pip6 = (prox_rte_ipv6_hdr *)(peth + 1);
pip6->vtc_flow = rte_cpu_to_be_32(IPv6_VERSION << 28);
pip6->proto = IPPROTO_IPIP;
pip6->payload_len = rte_cpu_to_be_16(ipv4_length);
if (tun_base->runtime_flags & TASK_TX_CRC) {
// We modified the TTL in the IPv4 header, hence have to recompute the IPv4 checksum
-#define TUNNEL_L2_LEN (sizeof(struct ether_hdr) + sizeof(struct ipv6_hdr))
- prox_ip_cksum(rx_mbuf, pip4, TUNNEL_L2_LEN, sizeof(struct ipv4_hdr), ptask->base.offload_crc);
+#define TUNNEL_L2_LEN (sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv6_hdr))
+ prox_ip_cksum(rx_mbuf, pip4, TUNNEL_L2_LEN, sizeof(prox_rte_ipv4_hdr), ptask->base.offload_crc);
}
return 0;
}
Code Review / samplevnf.git / blobdiff