summaryrefslogtreecommitdiffstats
path: root/VNFs/DPPD-PROX
diff options
context:
space:
mode:
Diffstat (limited to 'VNFs/DPPD-PROX')
-rw-r--r--VNFs/DPPD-PROX/Makefile6
-rw-r--r--VNFs/DPPD-PROX/README4
-rw-r--r--VNFs/DPPD-PROX/acl_field_def.h10
-rw-r--r--VNFs/DPPD-PROX/arp.h25
-rw-r--r--VNFs/DPPD-PROX/bng_pkts.h25
-rw-r--r--VNFs/DPPD-PROX/cmd_parser.c317
-rw-r--r--VNFs/DPPD-PROX/commands.c29
-rw-r--r--VNFs/DPPD-PROX/commands.h3
-rw-r--r--VNFs/DPPD-PROX/defaults.c14
-rw-r--r--VNFs/DPPD-PROX/defaults.h5
-rw-r--r--VNFs/DPPD-PROX/display.c12
-rw-r--r--VNFs/DPPD-PROX/display.h6
-rw-r--r--VNFs/DPPD-PROX/display_latency_distr.c190
-rw-r--r--VNFs/DPPD-PROX/display_latency_distr.h23
-rw-r--r--VNFs/DPPD-PROX/genl4_stream.h4
-rw-r--r--VNFs/DPPD-PROX/genl4_stream_tcp.c122
-rw-r--r--VNFs/DPPD-PROX/genl4_stream_udp.c16
-rw-r--r--VNFs/DPPD-PROX/handle_aggregator.c14
-rw-r--r--VNFs/DPPD-PROX/handle_arp.c8
-rw-r--r--VNFs/DPPD-PROX/handle_blockudp.c4
-rw-r--r--VNFs/DPPD-PROX/handle_cgnat.c18
-rw-r--r--VNFs/DPPD-PROX/handle_classify.c2
-rw-r--r--VNFs/DPPD-PROX/handle_esp.c138
-rw-r--r--VNFs/DPPD-PROX/handle_fm.c16
-rw-r--r--VNFs/DPPD-PROX/handle_gen.c62
-rw-r--r--VNFs/DPPD-PROX/handle_genl4.c16
-rw-r--r--VNFs/DPPD-PROX/handle_gre_decap_encap.c62
-rw-r--r--VNFs/DPPD-PROX/handle_impair.c22
-rw-r--r--VNFs/DPPD-PROX/handle_ipv6_tunnel.c70
-rw-r--r--VNFs/DPPD-PROX/handle_l2fwd.c20
-rw-r--r--VNFs/DPPD-PROX/handle_lat.c19
-rw-r--r--VNFs/DPPD-PROX/handle_lat.h10
-rw-r--r--VNFs/DPPD-PROX/handle_lb_5tuple.c10
-rw-r--r--VNFs/DPPD-PROX/handle_lb_net.c30
-rw-r--r--VNFs/DPPD-PROX/handle_lb_pos.c6
-rw-r--r--VNFs/DPPD-PROX/handle_lb_qinq.c14
-rw-r--r--VNFs/DPPD-PROX/handle_master.c8
-rw-r--r--VNFs/DPPD-PROX/handle_mplstag.c14
-rw-r--r--VNFs/DPPD-PROX/handle_nat.c6
-rw-r--r--VNFs/DPPD-PROX/handle_nsh.c32
-rw-r--r--VNFs/DPPD-PROX/handle_qinq_decap4.c32
-rw-r--r--VNFs/DPPD-PROX/handle_qinq_decap6.c8
-rw-r--r--VNFs/DPPD-PROX/handle_qinq_encap4.c8
-rw-r--r--VNFs/DPPD-PROX/handle_qinq_encap4.h8
-rw-r--r--VNFs/DPPD-PROX/handle_qinq_encap6.c4
-rw-r--r--VNFs/DPPD-PROX/handle_qos.c4
-rw-r--r--VNFs/DPPD-PROX/handle_routing.c14
-rw-r--r--VNFs/DPPD-PROX/handle_swap.c74
-rw-r--r--VNFs/DPPD-PROX/handle_untag.c12
-rw-r--r--VNFs/DPPD-PROX/hash_entry_types.h3
-rw-r--r--VNFs/DPPD-PROX/log.c11
-rw-r--r--VNFs/DPPD-PROX/log.h1
-rw-r--r--VNFs/DPPD-PROX/main.c6
-rw-r--r--VNFs/DPPD-PROX/mbuf_utils.h5
-rw-r--r--VNFs/DPPD-PROX/packet_utils.c34
-rw-r--r--VNFs/DPPD-PROX/packet_utils.h3
-rw-r--r--VNFs/DPPD-PROX/parse_utils.c2
-rw-r--r--VNFs/DPPD-PROX/parse_utils.h4
-rw-r--r--VNFs/DPPD-PROX/pkt_parser.h31
-rw-r--r--VNFs/DPPD-PROX/pkt_prototypes.h2
-rw-r--r--VNFs/DPPD-PROX/prox_args.c8
-rw-r--r--VNFs/DPPD-PROX/prox_cksum.c18
-rw-r--r--VNFs/DPPD-PROX/prox_cksum.h11
-rw-r--r--VNFs/DPPD-PROX/prox_compat.h68
-rw-r--r--VNFs/DPPD-PROX/prox_lua_types.c8
-rw-r--r--VNFs/DPPD-PROX/prox_lua_types.h8
-rw-r--r--VNFs/DPPD-PROX/prox_port_cfg.c14
-rw-r--r--VNFs/DPPD-PROX/prox_port_cfg.h5
-rw-r--r--VNFs/DPPD-PROX/qinq.h5
-rw-r--r--VNFs/DPPD-PROX/quit.h2
-rw-r--r--VNFs/DPPD-PROX/stats_latency.c24
-rw-r--r--VNFs/DPPD-PROX/stats_latency.h5
-rw-r--r--VNFs/DPPD-PROX/task_init.h5
-rw-r--r--VNFs/DPPD-PROX/version.h2
-rw-r--r--VNFs/DPPD-PROX/vxlangpe_nsh.h4
75 files changed, 1115 insertions, 750 deletions
diff --git a/VNFs/DPPD-PROX/Makefile b/VNFs/DPPD-PROX/Makefile
index bc11f5d8..f8bde421 100644
--- a/VNFs/DPPD-PROX/Makefile
+++ b/VNFs/DPPD-PROX/Makefile
@@ -1,5 +1,5 @@
##
-## Copyright (c) 2010-2017 Intel Corporation
+## Copyright (c) 2010-2019 Intel Corporation
##
## Licensed under the Apache License, Version 2.0 (the "License");
## you may not use this file except in compliance with the License.
@@ -133,7 +133,7 @@ CFLAGS += -DPROX_PREFETCH_OFFSET=2
#CFLAGS += -DASSERT
#CFLAGS += -DENABLE_EXTRA_USER_STATISTICS
CFLAGS += -DLATENCY_PER_PACKET
-CFLAGS += -DLATENCY_DETAILS
+CFLAGS += -DLATENCY_HISTOGRAM
CFLAGS += -DGRE_TP
CFLAGS += -std=gnu99
CFLAGS += -D_GNU_SOURCE # for PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
@@ -204,7 +204,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_PIPELINE) += thread_pipeline.c
SRCS-y += prox_args.c prox_cfg.c prox_cksum.c prox_port_cfg.c
SRCS-y += cfgfile.c clock.c commands.c cqm.c msr.c defaults.c
-SRCS-y += display.c display_latency.c display_mempools.c
+SRCS-y += display.c display_latency.c display_latency_distr.c display_mempools.c
SRCS-y += display_ports.c display_rings.c display_priority.c display_pkt_len.c display_l4gen.c display_tasks.c display_irq.c
SRCS-y += log.c hash_utils.c main.c parse_utils.c file_utils.c
SRCS-y += run.c input_conn.c input_curses.c
diff --git a/VNFs/DPPD-PROX/README b/VNFs/DPPD-PROX/README
index b4ccc2ea..1e4b3585 100644
--- a/VNFs/DPPD-PROX/README
+++ b/VNFs/DPPD-PROX/README
@@ -1,5 +1,5 @@
##
-## Copyright (c) 2010-2019 Intel Corporation
+## Copyright (c) 2010-2020 Intel Corporation
##
## Licensed under the Apache License, Version 2.0 (the "License");
## you may not use this file except in compliance with the License.
@@ -25,7 +25,7 @@ finer grained network functions like QoS, Routing, load-balancing...
Compiling and running this application
--------------------------------------
This application supports DPDK 16.04, 16.11, 16.11.1, 17.02, 17.05, 17.08,
-17.11, 18.02, 18.05, 18.08, 18.11, 19.02 and 19.05.
+17.11, 18.02, 18.05, 18.08, 18.11, 19.02, 19.05 and 19.08.
The following commands assume that the following variables have been set:
diff --git a/VNFs/DPPD-PROX/acl_field_def.h b/VNFs/DPPD-PROX/acl_field_def.h
index ede5bea7..4f05ae80 100644
--- a/VNFs/DPPD-PROX/acl_field_def.h
+++ b/VNFs/DPPD-PROX/acl_field_def.h
@@ -24,9 +24,9 @@
#include "qinq.h"
struct pkt_eth_ipv4_udp {
- struct ether_hdr ether_hdr;
- struct ipv4_hdr ipv4_hdr;
- struct udp_hdr udp_hdr;
+ prox_rte_ether_hdr ether_hdr;
+ prox_rte_ipv4_hdr ipv4_hdr;
+ prox_rte_udp_hdr udp_hdr;
} __attribute__((packed));
static struct rte_acl_field_def pkt_eth_ipv4_udp_defs[] = {
@@ -73,8 +73,8 @@ static struct rte_acl_field_def pkt_eth_ipv4_udp_defs[] = {
struct pkt_qinq_ipv4_udp {
struct qinq_hdr qinq_hdr;
- struct ipv4_hdr ipv4_hdr;
- struct udp_hdr udp_hdr;
+ prox_rte_ipv4_hdr ipv4_hdr;
+ prox_rte_udp_hdr udp_hdr;
};
static struct rte_acl_field_def pkt_qinq_ipv4_udp_defs[] = {
diff --git a/VNFs/DPPD-PROX/arp.h b/VNFs/DPPD-PROX/arp.h
index 488008d7..c0f74cbb 100644
--- a/VNFs/DPPD-PROX/arp.h
+++ b/VNFs/DPPD-PROX/arp.h
@@ -18,6 +18,7 @@
#define _ARP_H_
#include <rte_ether.h>
+#include "prox_compat.h"
#include "etypes.h"
#include "mbuf_utils.h"
@@ -25,9 +26,9 @@
#define ARP_REPLY 0x200
struct _arp_ipv4 {
- struct ether_addr sha; /* Sender hardware address */
+ prox_rte_ether_addr sha; /* Sender hardware address */
uint32_t spa; /* Sender protocol address */
- struct ether_addr tha; /* Target hardware address */
+ prox_rte_ether_addr tha; /* Target hardware address */
uint32_t tpa; /* Target protocol address */
} __attribute__((__packed__));
typedef struct _arp_ipv4 arp_ipv4_t;
@@ -42,7 +43,7 @@ struct my_arp_t {
} __attribute__((__packed__));
struct ether_hdr_arp {
- struct ether_hdr ether_hdr;
+ prox_rte_ether_hdr ether_hdr;
struct my_arp_t arp;
};
@@ -51,21 +52,21 @@ static int arp_is_gratuitous(struct ether_hdr_arp *hdr)
return hdr->arp.data.spa == hdr->arp.data.tpa;
}
-static inline void build_arp_reply(struct ether_hdr_arp *hdr_arp, struct ether_addr *s_addr)
+static inline void build_arp_reply(struct ether_hdr_arp *hdr_arp, prox_rte_ether_addr *s_addr)
{
uint32_t ip_source = hdr_arp->arp.data.spa;
- memcpy(hdr_arp->ether_hdr.d_addr.addr_bytes, hdr_arp->ether_hdr.s_addr.addr_bytes, sizeof(struct ether_addr));
- memcpy(hdr_arp->ether_hdr.s_addr.addr_bytes, s_addr, sizeof(struct ether_addr));
+ memcpy(hdr_arp->ether_hdr.d_addr.addr_bytes, hdr_arp->ether_hdr.s_addr.addr_bytes, sizeof(prox_rte_ether_addr));
+ memcpy(hdr_arp->ether_hdr.s_addr.addr_bytes, s_addr, sizeof(prox_rte_ether_addr));
hdr_arp->arp.data.spa = hdr_arp->arp.data.tpa;
hdr_arp->arp.data.tpa = ip_source;
hdr_arp->arp.oper = 0x200;
- memcpy(&hdr_arp->arp.data.tha, &hdr_arp->arp.data.sha, sizeof(struct ether_addr));
- memcpy(&hdr_arp->arp.data.sha, s_addr, sizeof(struct ether_addr));
+ memcpy(&hdr_arp->arp.data.tha, &hdr_arp->arp.data.sha, sizeof(prox_rte_ether_addr));
+ memcpy(&hdr_arp->arp.data.sha, s_addr, sizeof(prox_rte_ether_addr));
}
-static inline void build_arp_request(struct rte_mbuf *mbuf, struct ether_addr *src_mac, uint32_t ip_dst, uint32_t ip_src)
+static inline void build_arp_request(struct rte_mbuf *mbuf, prox_rte_ether_addr *src_mac, uint32_t ip_dst, uint32_t ip_src)
{
struct ether_hdr_arp *hdr_arp = rte_pktmbuf_mtod(mbuf, struct ether_hdr_arp *);
uint64_t mac_bcast = 0xFFFFFFFFFFFF;
@@ -83,11 +84,11 @@ static inline void build_arp_request(struct rte_mbuf *mbuf, struct ether_addr *s
hdr_arp->arp.oper = 0x100;
hdr_arp->arp.data.spa = ip_src;
hdr_arp->arp.data.tpa = ip_dst;
- memset(&hdr_arp->arp.data.tha, 0, sizeof(struct ether_addr));
- memcpy(&hdr_arp->arp.data.sha, src_mac, sizeof(struct ether_addr));
+ memset(&hdr_arp->arp.data.tha, 0, sizeof(prox_rte_ether_addr));
+ memcpy(&hdr_arp->arp.data.sha, src_mac, sizeof(prox_rte_ether_addr));
}
-static void create_mac(struct ether_hdr_arp *hdr, struct ether_addr *addr)
+static void create_mac(struct ether_hdr_arp *hdr, prox_rte_ether_addr *addr)
{
addr->addr_bytes[0] = 0x2;
addr->addr_bytes[1] = 0;
diff --git a/VNFs/DPPD-PROX/bng_pkts.h b/VNFs/DPPD-PROX/bng_pkts.h
index 82e6199c..50780e3b 100644
--- a/VNFs/DPPD-PROX/bng_pkts.h
+++ b/VNFs/DPPD-PROX/bng_pkts.h
@@ -22,6 +22,7 @@
#include <rte_udp.h>
#include <rte_byteorder.h>
+#include "prox_compat.h"
#include "gre.h"
#include "mpls.h"
#include "qinq.h"
@@ -32,10 +33,10 @@ struct cpe_pkt {
#ifdef USE_QINQ
struct qinq_hdr qinq_hdr;
#else
- struct ether_hdr ether_hdr;
+ prox_rte_ether_hdr ether_hdr;
#endif
- struct ipv4_hdr ipv4_hdr;
- struct udp_hdr udp_hdr;
+ prox_rte_ipv4_hdr ipv4_hdr;
+ prox_rte_udp_hdr udp_hdr;
} __attribute__((packed));
struct cpe_packet_arp {
@@ -47,25 +48,25 @@ struct cpe_packet_arp {
going to the core netwerk. Payload may follow
after the headers, but no need to touch that. */
struct core_net_pkt_m {
- struct ether_hdr ether_hdr;
+ prox_rte_ether_hdr ether_hdr;
#ifdef MPLS_ROUTING
union {
struct mpls_hdr mpls;
uint32_t mpls_bytes;
};
#endif
- struct ipv4_hdr tunnel_ip_hdr;
+ prox_rte_ipv4_hdr tunnel_ip_hdr;
struct gre_hdr gre_hdr;
- struct ipv4_hdr ip_hdr;
- struct udp_hdr udp_hdr;
+ prox_rte_ipv4_hdr ip_hdr;
+ prox_rte_udp_hdr udp_hdr;
} __attribute__((packed));
struct core_net_pkt {
- struct ether_hdr ether_hdr;
- struct ipv4_hdr tunnel_ip_hdr;
+ prox_rte_ether_hdr ether_hdr;
+ prox_rte_ipv4_hdr tunnel_ip_hdr;
struct gre_hdr gre_hdr;
- struct ipv4_hdr ip_hdr;
- struct udp_hdr udp_hdr;
+ prox_rte_ipv4_hdr ip_hdr;
+ prox_rte_udp_hdr udp_hdr;
} __attribute__((packed));
#define UPSTREAM_DELTA ((uint32_t)(sizeof(struct core_net_pkt) - sizeof(struct cpe_pkt)))
@@ -86,7 +87,7 @@ static inline void extract_key_cpe(struct rte_mbuf *mbuf, uint64_t* key)
#endif
}
-static inline void key_core(struct gre_hdr* gre, __attribute__((unused)) struct ipv4_hdr* ip, uint64_t* key)
+static inline void key_core(struct gre_hdr* gre, __attribute__((unused)) prox_rte_ipv4_hdr* ip, uint64_t* key)
{
struct cpe_key *cpe_key = (struct cpe_key*)key;
diff --git a/VNFs/DPPD-PROX/cmd_parser.c b/VNFs/DPPD-PROX/cmd_parser.c
index 3ad5b534..0dd173f3 100644
--- a/VNFs/DPPD-PROX/cmd_parser.c
+++ b/VNFs/DPPD-PROX/cmd_parser.c
@@ -1,5 +1,5 @@
/*
-// Copyright (c) 2010-2017 Intel Corporation
+// Copyright (c) 2010-2019 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -731,8 +731,8 @@ static int parse_cmd_set_random(const char *str, struct input *input)
if ((!task_is_mode_and_submode(lcore_id, task_id, "gen", "")) && (!task_is_mode_and_submode(lcore_id, task_id, "gen", "l3"))) {
plog_err("Core %u task %u is not generating packets\n", lcore_id, task_id);
}
- else if (offset > ETHER_MAX_LEN) {
- plog_err("Offset out of range (must be less then %u)\n", ETHER_MAX_LEN);
+ else if (offset > PROX_RTE_ETHER_MAX_LEN) {
+ plog_err("Offset out of range (must be less then %u)\n", PROX_RTE_ETHER_MAX_LEN);
}
else if (value_len > 4) {
plog_err("Length out of range (must be less then 4)\n");
@@ -1256,7 +1256,7 @@ static int parse_cmd_tot_imissed_tot(const char *str, struct input *input)
static int parse_cmd_enable_multicast(const char *str, struct input *input)
{
uint8_t port_id;
- struct ether_addr mac;
+ prox_rte_ether_addr mac;
if (sscanf(str, "%hhu %hhx:%hhx:%hhx:%hhx:%hhx:%hhx", &port_id, mac.addr_bytes, mac.addr_bytes + 1, mac.addr_bytes + 2, mac.addr_bytes + 3, mac.addr_bytes + 4, mac.addr_bytes + 5 ) != 7) {
return -1;
@@ -1268,7 +1268,7 @@ static int parse_cmd_enable_multicast(const char *str, struct input *input)
static int parse_cmd_disable_multicast(const char *str, struct input *input)
{
uint8_t port_id;
- struct ether_addr mac;
+ prox_rte_ether_addr mac;
if (sscanf(str, "%hhu %hhx:%hhx:%hhx:%hhx:%hhx:%hhx", &port_id, mac.addr_bytes, mac.addr_bytes + 1, mac.addr_bytes + 2, mac.addr_bytes + 3, mac.addr_bytes + 4, mac.addr_bytes + 5 ) != 7) {
return -1;
@@ -1693,11 +1693,15 @@ static int parse_cmd_core_stats(const char *str, struct input *input)
return 0;
}
-static int parse_cmd_dp_core_stats(const char *str, struct input *input)
+typedef void (*parser_handler)(unsigned, unsigned, struct input *);
+static int handle_cores_tasks(const char *str, struct input *input, const char *mode_str, const char *mode_name, parser_handler f)
{
- unsigned lcores[RTE_MAX_LCORE], tasks[MAX_TASKS_PER_CORE], lcore_id, task_id, nb_cores, nb_tasks;
-
// This function either outputs a single line, in case of syntax error on the lists of cores and/or tasks
+ // or outputs (nb_cores * nb_tasks) lines, one line for each core/task pair:
+ // - if the core/task pair is invalid, the output line reports an error
+ // - otherwise, the output line provides the latency statistics for the core/task pair
+
+ unsigned lcores[RTE_MAX_LCORE], tasks[MAX_TASKS_PER_CORE], lcore_id, task_id, nb_cores, nb_tasks;
if (parse_cores_tasks(str, lcores, tasks, &nb_cores, &nb_tasks)) {
if (input->reply) {
char buf[128];
@@ -1707,9 +1711,6 @@ static int parse_cmd_dp_core_stats(const char *str, struct input *input)
return -1;
}
- // or outputs (nb_cores * nb_tasks) lines, one line for each core/task pair:
- // - if the core/task pair is invalid, the output line reports an error
- // - otherwise, the output line provides the dataplane statistics for the core/task pair
for (unsigned int i = 0; i < nb_cores; i++) {
for (unsigned int j = 0; j < nb_tasks; j++) {
lcore_id = lcores[i];
@@ -1724,122 +1725,174 @@ static int parse_cmd_dp_core_stats(const char *str, struct input *input)
}
continue;
}
- uint64_t tot_rx = stats_core_task_tot_rx(lcore_id, task_id);
- uint64_t tot_tx = stats_core_task_tot_tx(lcore_id, task_id);
- uint64_t tot_tx_fail = stats_core_task_tot_tx_fail(lcore_id, task_id);
- uint64_t tot_rx_non_dp = stats_core_task_tot_rx_non_dp(lcore_id, task_id);
- uint64_t tot_tx_non_dp = stats_core_task_tot_tx_non_dp(lcore_id, task_id);
- uint64_t tot_drop = stats_core_task_tot_drop(lcore_id, task_id);
- uint64_t last_tsc = stats_core_task_last_tsc(lcore_id, task_id);
-
- if (input->reply) {
- char buf[128];
- snprintf(buf, sizeof(buf),
- "%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%u,%u\n",
- tot_rx, tot_tx, tot_rx_non_dp, tot_tx_non_dp, tot_drop, tot_tx_fail, last_tsc, rte_get_tsc_hz(), lcore_id, task_id);
- input->reply(input, buf, strlen(buf));
- }
- else {
- plog_info("core: %u, task: %u, RX: %"PRIu64", TX: %"PRIu64", RX_NON_DP: %"PRIu64", TX_NON_DP: %"PRIu64", DROP: %"PRIu64", TX_FAIL: %"PRIu64"\n",
- lcore_id, task_id, tot_rx, tot_tx, tot_rx_non_dp, tot_tx_non_dp, tot_drop, tot_tx_fail);
+ if ((mode_str) && (!task_is_mode(lcore_id, task_id, mode_str))) {
+ if (input->reply) {
+ char buf[128];
+ snprintf(buf, sizeof(buf), "error: core %u task %u is not measuring %s\n", lcore_id, task_id, mode_name);
+ input->reply(input, buf, strlen(buf));
+ } else {
+ plog_info("error: core %u task %u is not measuring %s\n", lcore_id, task_id, mode_name);
+ }
+ continue;
}
+ f(lcore_id, task_id, input);
}
}
return 0;
}
-static int parse_cmd_lat_stats(const char *str, struct input *input)
+static void handle_dp_core_stats(unsigned lcore_id, unsigned task_id, struct input *input)
{
- unsigned lcores[RTE_MAX_LCORE], tasks[MAX_TASKS_PER_CORE], lcore_id, task_id, nb_cores, nb_tasks;
+ uint64_t tot_rx = stats_core_task_tot_rx(lcore_id, task_id);
+ uint64_t tot_tx = stats_core_task_tot_tx(lcore_id, task_id);
+ uint64_t tot_tx_fail = stats_core_task_tot_tx_fail(lcore_id, task_id);
+ uint64_t tot_rx_non_dp = stats_core_task_tot_rx_non_dp(lcore_id, task_id);
+ uint64_t tot_tx_non_dp = stats_core_task_tot_tx_non_dp(lcore_id, task_id);
+ uint64_t tot_drop = stats_core_task_tot_drop(lcore_id, task_id);
+ uint64_t last_tsc = stats_core_task_last_tsc(lcore_id, task_id);
- // This function either outputs a single line, in case of syntax error on the lists of cores and/or tasks
- if (parse_cores_tasks(str, lcores, tasks, &nb_cores, &nb_tasks)) {
+ if (input->reply) {
+ char buf[128];
+ snprintf(buf, sizeof(buf),
+ "%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%u,%u\n",
+ tot_rx, tot_tx, tot_rx_non_dp, tot_tx_non_dp, tot_drop, tot_tx_fail, last_tsc, rte_get_tsc_hz(), lcore_id, task_id);
+ input->reply(input, buf, strlen(buf));
+ }
+ else {
+ plog_info("core: %u, task: %u, RX: %"PRIu64", TX: %"PRIu64", RX_NON_DP: %"PRIu64", TX_NON_DP: %"PRIu64", DROP: %"PRIu64", TX_FAIL: %"PRIu64"\n",
+ lcore_id, task_id, tot_rx, tot_tx, tot_rx_non_dp, tot_tx_non_dp, tot_drop, tot_tx_fail);
+ }
+}
+
+static void handle_lat_stats(unsigned lcore_id, unsigned task_id, struct input *input)
+{
+ struct stats_latency *stats = stats_latency_find(lcore_id, task_id);
+ struct stats_latency *tot = stats_latency_tot_find(lcore_id, task_id);
+ if (!stats || !tot) {
if (input->reply) {
char buf[128];
- snprintf(buf, sizeof(buf), "error: invalid syntax\n");
+ snprintf(buf, sizeof(buf),
+ "error: core %u task %u stats = %p tot = %p\n",
+ lcore_id, task_id, stats, tot);
input->reply(input, buf, strlen(buf));
+ } else {
+ plog_info("error: core %u task %u stats = %p tot = %p\n",
+ lcore_id, task_id, stats, tot);
}
- return -1;
+ return;
}
- // or outputs (nb_cores * nb_tasks) lines, one line for each core/task pair:
- // - if the core/task pair is invalid, the output line reports an error
- // - otherwise, the output line provides the latency statistics for the core/task pair
- for (unsigned int i = 0; i < nb_cores; i++) {
- for (unsigned int j = 0; j < nb_tasks; j++) {
- lcore_id = lcores[i];
- task_id = tasks[j];
- if (core_task_is_valid(lcore_id, task_id) == 0) {
- if (input->reply) {
- char buf[128];
- snprintf(buf, sizeof(buf), "error: invalid core %u, task %u\n", lcore_id, task_id);
- input->reply(input, buf, strlen(buf));
- } else {
- plog_info("error: invalid core %u, task %u\n", lcore_id, task_id);
- }
- continue;
- }
- if (!task_is_mode(lcore_id, task_id, "lat")) {
- if (input->reply) {
- char buf[128];
- snprintf(buf, sizeof(buf), "error: core %u task %u is not measuring latency\n", lcore_id, task_id);
- input->reply(input, buf, strlen(buf));
- } else {
- plog_info("error: core %u task %u is not measuring latency\n", lcore_id, task_id);
- }
- continue;
- }
+ uint64_t last_tsc = stats_core_task_last_tsc(lcore_id, task_id);
+ uint64_t lat_min_usec = time_unit_to_usec(&stats->min.time);
+ uint64_t lat_max_usec = time_unit_to_usec(&stats->max.time);
+ uint64_t tot_lat_min_usec = time_unit_to_usec(&tot->min.time);
+ uint64_t tot_lat_max_usec = time_unit_to_usec(&tot->max.time);
+ uint64_t lat_avg_usec = time_unit_to_usec(&stats->avg.time);
- struct stats_latency *stats = stats_latency_find(lcore_id, task_id);
- struct stats_latency *tot = stats_latency_tot_find(lcore_id, task_id);
- if (!stats || !tot) {
- if (input->reply) {
- char buf[128];
- snprintf(buf, sizeof(buf),
- "error: core %u task %u stats = %p tot = %p\n",
- lcore_id, task_id, stats, tot);
- input->reply(input, buf, strlen(buf));
- } else {
- plog_info("error: core %u task %u stats = %p tot = %p\n",
- lcore_id, task_id, stats, tot);
- }
- continue;
- }
+ if (input->reply) {
+ char buf[128];
+ snprintf(buf, sizeof(buf),
+ "%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%u,%u\n",
+ lat_min_usec,
+ lat_max_usec,
+ lat_avg_usec,
+ tot_lat_min_usec,
+ tot_lat_max_usec,
+ last_tsc,
+ rte_get_tsc_hz(),
+ lcore_id,
+ task_id);
+ input->reply(input, buf, strlen(buf));
+ }
+ else {
+ plog_info("core: %u, task: %u, min: %"PRIu64", max: %"PRIu64", avg: %"PRIu64", min since reset: %"PRIu64", max since reset: %"PRIu64"\n",
+ lcore_id,
+ task_id,
+ lat_min_usec,
+ lat_max_usec,
+ lat_avg_usec,
+ tot_lat_min_usec,
+ tot_lat_max_usec);
+ }
+}
- uint64_t last_tsc = stats_core_task_last_tsc(lcore_id, task_id);
- uint64_t lat_min_usec = time_unit_to_usec(&stats->min.time);
- uint64_t lat_max_usec = time_unit_to_usec(&stats->max.time);
- uint64_t tot_lat_min_usec = time_unit_to_usec(&tot->min.time);
- uint64_t tot_lat_max_usec = time_unit_to_usec(&tot->max.time);
- uint64_t lat_avg_usec = time_unit_to_usec(&stats->avg.time);
+#ifdef LATENCY_HISTOGRAM
+static void handle_latency_histogram(unsigned lcore_id, unsigned task_id, struct input *input)
+{
+ uint64_t *buckets;
- if (input->reply) {
- char buf[128];
- snprintf(buf, sizeof(buf),
- "%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%u,%u\n",
- lat_min_usec,
- lat_max_usec,
- lat_avg_usec,
- tot_lat_min_usec,
- tot_lat_max_usec,
- last_tsc,
- rte_get_tsc_hz(),
- lcore_id,
- task_id);
- input->reply(input, buf, strlen(buf));
- }
- else {
- plog_info("core: %u, task: %u, min: %"PRIu64", max: %"PRIu64", avg: %"PRIu64", min since reset: %"PRIu64", max since reset: %"PRIu64"\n",
- lcore_id,
- task_id,
- lat_min_usec,
- lat_max_usec,
- lat_avg_usec,
- tot_lat_min_usec,
- tot_lat_max_usec);
- }
+ stats_core_lat_histogram(lcore_id, task_id, &buckets);
+
+ if (buckets == NULL) {
+ if (input->reply) {
+ char buf[128];
+ snprintf(buf, sizeof(buf), "error: unexpected NULL bucket\n");
+ input->reply(input, buf, strlen(buf));
}
+ return;
+ }
+
+ if (input->reply) {
+ char buf[4096] = {0};
+ for (size_t i = 0; i < LAT_BUCKET_COUNT; i++)
+ sprintf(buf+strlen(buf), "Bucket [%zu]: %"PRIu64"\n", i, buckets[i]);
+ input->reply(input, buf, strlen(buf));
+ }
+ else {
+ for (size_t i = 0; i < LAT_BUCKET_COUNT; i++)
+ if (buckets[i])
+ plog_info("Bucket [%zu]: %"PRIu64"\n", i, buckets[i]);
+ }
+}
+
+static void handle_stats_and_packets(unsigned lcore_id, unsigned task_id, struct input *input)
+{
+ handle_lat_stats(lcore_id, task_id, input);
+ handle_latency_histogram(lcore_id, task_id, input);
+}
+#endif
+
+static int parse_cmd_dp_core_stats(const char *str, struct input *input)
+{
+ handle_cores_tasks(str, input, NULL, NULL, handle_dp_core_stats);
+ return 0;
+}
+
+static int parse_cmd_lat_stats(const char *str, struct input *input)
+{
+ handle_cores_tasks(str, input, "lat", "latency", handle_lat_stats);
+ return 0;
+}
+
+static int parse_cmd_lat_packets(const char *str, struct input *input)
+{
+#ifdef LATENCY_HISTOGRAM
+ handle_cores_tasks(str, input, "lat", "latency", handle_latency_histogram);
+#else
+ if (input->reply) {
+ char buf[128];
+ snprintf(buf, sizeof(buf), "error: invalid syntax (LATENCY_HISTOGRAM disabled)\n");
+ input->reply(input, buf, strlen(buf));
+ } else {
+ plog_info("LATENCY_HISTOGRAMS disabled\n");
}
+#endif
+ return 0;
+}
+
+static int parse_cmd_lat_stats_and_packets(const char *str, struct input *input)
+{
+#ifdef LATENCY_HISTOGRAM
+ handle_cores_tasks(str, input, "lat", "latency", handle_stats_and_packets);
+#else
+ if (input->reply) {
+ char buf[128];
+ snprintf(buf, sizeof(buf), "error: invalid syntax (LATENCY_HISTOGRAMS disabled)\n");
+ input->reply(input, buf, strlen(buf));
+ } else {
+ plog_info("LATENCY_HISTOGRAMS disabled\n");
+ }
+#endif
return 0;
}
@@ -1888,53 +1941,6 @@ static int parse_cmd_irq(const char *str, struct input *input)
return 0;
}
-static void task_lat_show_latency_histogram(uint8_t lcore_id, uint8_t task_id, struct input *input)
-{
-#ifdef LATENCY_HISTOGRAM
- uint64_t *buckets;
-
- stats_core_lat_histogram(lcore_id, task_id, &buckets);
-
- if (buckets == NULL)
- return;
-
- if (input->reply) {
- char buf[4096] = {0};
- for (size_t i = 0; i < 128; i++)
- sprintf(buf+strlen(buf), "Bucket [%zu]: %"PRIu64"\n", i, buckets[i]);
- input->reply(input, buf, strlen(buf));
- }
- else {
- for (size_t i = 0; i < 128; i++)
- if (buckets[i])
- plog_info("Bucket [%zu]: %"PRIu64"\n", i, buckets[i]);
- }
-#else
- plog_info("LATENCY_DETAILS disabled\n");
-#endif
-}
-
-static int parse_cmd_lat_packets(const char *str, struct input *input)
-{
- unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, nb_cores;
-
- if (parse_cores_task(str, lcores, &task_id, &nb_cores))
- return -1;
-
- if (cores_task_are_valid(lcores, task_id, nb_cores)) {
- for (unsigned int i = 0; i < nb_cores; i++) {
- lcore_id = lcores[i];
- if (!task_is_mode(lcore_id, task_id, "lat")) {
- plog_err("Core %u task %u is not measuring latency\n", lcore_id, task_id);
- }
- else {
- task_lat_show_latency_histogram(lcore_id, task_id, input);
- }
- }
- }
- return 0;
-}
-
static int parse_cmd_cgnat_public_hash(const char *str, struct input *input)
{
unsigned lcores[RTE_MAX_LCORE], lcore_id, task_id, nb_cores;
@@ -2161,6 +2167,7 @@ static struct cmd_str cmd_strings[] = {
{"irq stats", "<core id> <task id>", "Print irq related infos", parse_cmd_irq},
{"show irq buckets", "<core id> <task id>", "Print irq buckets", parse_cmd_show_irq_buckets},
{"lat packets", "<core id> <task id>", "Print the latency for each of the last set of packets", parse_cmd_lat_packets},
+ {"lat all stats", "<core id> <task id>", "Print the latency for each of the last set of packets as well as latency distribution", parse_cmd_lat_stats_and_packets},
{"accuracy limit", "<core id> <task id> <nsec>", "Only consider latency of packets that were measured with an error no more than <nsec>", parse_cmd_accuracy},
{"core stats", "<core id> <task id>", "Print rx/tx/drop for task <task id> running on core <core id>", parse_cmd_core_stats},
{"dp core stats", "<core id> <task id>", "Print rx/tx/non_dp_rx/non_dp_tx/drop for task <task id> running on core <core id>", parse_cmd_dp_core_stats},
diff --git a/VNFs/DPPD-PROX/commands.c b/VNFs/DPPD-PROX/commands.c
index a66f4888..df5e69cd 100644
--- a/VNFs/DPPD-PROX/commands.c
+++ b/VNFs/DPPD-PROX/commands.c
@@ -246,7 +246,7 @@ static struct size_unit to_size_unit(uint64_t bytes)
return ret;
}
-static int add_multicast_addr(uint8_t port_id, struct ether_addr *addr)
+static int add_multicast_addr(uint8_t port_id, prox_rte_ether_addr *addr)
{
unsigned int i;
int rc = 0;
@@ -258,13 +258,13 @@ static int add_multicast_addr(uint8_t port_id, struct ether_addr *addr)
return -1;
}
for (i = 0; i < port_cfg->nb_mc_addr; i++) {
- if (is_same_ether_addr(addr, &port_cfg->mc_addr[i])) {
+ if (prox_rte_is_same_ether_addr(addr, &port_cfg->mc_addr[i])) {
plog_info("multicast address already added to port\n");
return -1;
}
}
- ether_addr_copy(addr, &port_cfg->mc_addr[port_cfg->nb_mc_addr]);
+ prox_rte_ether_addr_copy(addr, &port_cfg->mc_addr[port_cfg->nb_mc_addr]);
if ((rc = rte_eth_dev_set_mc_addr_list(port_id, port_cfg->mc_addr, port_cfg->nb_mc_addr + 1)) != 0) {
plog_err("rte_eth_dev_set_mc_addr_list returns %d on port %u\n", rc, port_id);
return rc;
@@ -275,7 +275,7 @@ static int add_multicast_addr(uint8_t port_id, struct ether_addr *addr)
return rc;
}
-static int del_multicast_addr(uint8_t port_id, struct ether_addr *addr)
+static int del_multicast_addr(uint8_t port_id, prox_rte_ether_addr *addr)
{
unsigned int i;
int rc = 0;
@@ -283,14 +283,14 @@ static int del_multicast_addr(uint8_t port_id, struct ether_addr *addr)
struct prox_port_cfg* port_cfg = &prox_port_cfg[port_id];
for (i = 0; i < port_cfg->nb_mc_addr; i++) {
- if (is_same_ether_addr(addr, &port_cfg->mc_addr[i])) {
+ if (prox_rte_is_same_ether_addr(addr, &port_cfg->mc_addr[i])) {
// Copy last address to the slot to be deleted
- ether_addr_copy(&port_cfg->mc_addr[port_cfg->nb_mc_addr-1], &port_cfg->mc_addr[i]);
+ prox_rte_ether_addr_copy(&port_cfg->mc_addr[port_cfg->nb_mc_addr-1], &port_cfg->mc_addr[i]);
if ((rc = rte_eth_dev_set_mc_addr_list(port_id, port_cfg->mc_addr, port_cfg->nb_mc_addr - 1)) != 0) {
plog_err("rte_eth_dev_set_mc_addr_list returns %d on port %u\n", rc, port_id);
// When set failed, let restore the situation we were before calling the function...
- ether_addr_copy(addr, &port_cfg->mc_addr[i]);
+ prox_rte_ether_addr_copy(addr, &port_cfg->mc_addr[i]);
return rc;
}
port_cfg->nb_mc_addr--;
@@ -347,15 +347,17 @@ static void get_hp_sz_string(char *sz_str, uint64_t hp_sz)
// Unused for now, keep for reference
static int print_all_segments(const struct rte_memseg_list *memseg_list, const struct rte_memseg *memseg, void *arg)
{
- struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
- int memseg_list_idx, memseg_idx;
+ int memseg_list_idx = 0, memseg_idx;
int n = (*(int *)arg)++;
+#if RTE_VERSION < RTE_VERSION_NUM(19,8,0,0)
+ struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
memseg_list_idx = memseg_list - mcfg->memsegs;
if ((memseg_list_idx < 0) || (memseg_list_idx >= RTE_MAX_MEMSEG_LISTS)) {
plog_err("Invalid memseg_list_idx = %d; memseg_list = %p, mcfg->memsegs = %p\n", memseg_list_idx, memseg_list, mcfg->memsegs);
return -1;
}
+#endif
memseg_idx = rte_fbarray_find_idx(&memseg_list->memseg_arr, memseg);
if (memseg_idx < 0) {
plog_err("Invalid memseg_idx = %d; memseg_list = %p, memseg = %p\n", memseg_idx, memseg_list, memseg);
@@ -381,15 +383,17 @@ static int print_all_segments(const struct rte_memseg_list *memseg_list, const s
// Contiguous segments are shown as 1 big segment
static int print_segments(const struct rte_memseg_list *memseg_list, const struct rte_memseg *memseg, size_t len, void *arg)
{
- struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
- int memseg_list_idx, memseg_idx;
+ int memseg_list_idx = 0, memseg_idx;
static int n = 0;
+#if RTE_VERSION < RTE_VERSION_NUM(19,8,0,0)
+ struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
memseg_list_idx = memseg_list - mcfg->memsegs;
if ((memseg_list_idx < 0) || (memseg_list_idx >= RTE_MAX_MEMSEG_LISTS)) {
plog_err("Invalid memseg_list_idx = %d; memseg_list = %p, mcfg->memsegs = %p\n", memseg_list_idx, memseg_list, mcfg->memsegs);
return -1;
}
+#endif
memseg_idx = rte_fbarray_find_idx(&memseg_list->memseg_arr, memseg);
if (memseg_idx < 0) {
plog_err("Invalid memseg_idx = %d; memseg_list = %p, memseg = %p\n", memseg_idx, memseg_list, memseg);
@@ -412,6 +416,7 @@ static int print_segments(const struct rte_memseg_list *memseg_list, const struc
}
#endif
+
void cmd_mem_layout(void)
{
#if RTE_VERSION < RTE_VERSION_NUM(18,5,0,0)
@@ -957,7 +962,7 @@ void cmd_reset_port(uint8_t portid)
}
}
-void cmd_multicast(uint8_t port_id, unsigned int val, struct ether_addr *mac)
+void cmd_multicast(uint8_t port_id, unsigned int val, prox_rte_ether_addr *mac)
{
if (!port_is_active(port_id)) {
return;
diff --git a/VNFs/DPPD-PROX/commands.h b/VNFs/DPPD-PROX/commands.h
index 291930ff..5ddb81e2 100644
--- a/VNFs/DPPD-PROX/commands.h
+++ b/VNFs/DPPD-PROX/commands.h
@@ -19,6 +19,7 @@
#include <inttypes.h>
#include <rte_ether.h>
+#include "prox_compat.h"
struct input;
@@ -65,7 +66,7 @@ void cmd_set_cache_class(uint32_t lcore_id, uint32_t set);
void cmd_cache_reset(void);
void cmd_reset_port(uint8_t port_id);
-void cmd_multicast(uint8_t port_id, unsigned int val, struct ether_addr *mac);
+void cmd_multicast(uint8_t port_id, unsigned int val, prox_rte_ether_addr *mac);
int reconnect_task(uint32_t lcore_id, uint32_t task_id);
int bypass_task(uint32_t lcore_id, uint32_t task_id);
diff --git a/VNFs/DPPD-PROX/defaults.c b/VNFs/DPPD-PROX/defaults.c
index 3dbb7ece..27240484 100644
--- a/VNFs/DPPD-PROX/defaults.c
+++ b/VNFs/DPPD-PROX/defaults.c
@@ -48,7 +48,7 @@
static const struct rte_eth_conf default_port_conf = {
.rxmode = {
.mq_mode = 0,
- .max_rx_pkt_len = PROX_MTU + ETHER_HDR_LEN + ETHER_CRC_LEN
+ .max_rx_pkt_len = PROX_MTU + PROX_RTE_ETHER_HDR_LEN + PROX_RTE_ETHER_CRC_LEN
},
.rx_adv_conf = {
.rss_conf = {
@@ -94,7 +94,11 @@ static struct rte_sched_pipe_params pipe_params_default = {
.tc_rate = {TEN_GIGABIT / NB_PIPES, TEN_GIGABIT / NB_PIPES, TEN_GIGABIT / NB_PIPES, TEN_GIGABIT / NB_PIPES},
.tc_period = 40,
+#if RTE_VERSION >= RTE_VERSION_NUM(19,8,0,0)
+ .wrr_weights = {1, 1, 1, 1},
+#else
.wrr_weights = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
+#endif
};
static struct rte_sched_subport_params subport_params_default = {
@@ -146,14 +150,14 @@ void set_task_defaults(struct prox_cfg* prox_cfg, struct lcore_cfg* lcore_cfg_in
targ->mapping[i] = i; // identity
}
- targ->cbs = ETHER_MAX_LEN;
- targ->ebs = ETHER_MAX_LEN;
- targ->pbs = ETHER_MAX_LEN;
+ targ->cbs = PROX_RTE_ETHER_MAX_LEN;
+ targ->ebs = PROX_RTE_ETHER_MAX_LEN;
+ targ->pbs = PROX_RTE_ETHER_MAX_LEN;
targ->n_max_rules = 1024;
targ->ring_size = RING_RX_SIZE;
targ->nb_cache_mbuf = MAX_PKT_BURST * 4;
- targ->overhead = ETHER_CRC_LEN + 20;
+ targ->overhead = PROX_RTE_ETHER_CRC_LEN + 20;
targ->tunnel_hop_limit = 3;
targ->ctrl_freq = 1000;
diff --git a/VNFs/DPPD-PROX/defaults.h b/VNFs/DPPD-PROX/defaults.h
index 8f850d03..8ce59530 100644
--- a/VNFs/DPPD-PROX/defaults.h
+++ b/VNFs/DPPD-PROX/defaults.h
@@ -18,6 +18,7 @@
#define _DEFAULTS_H_
#include <rte_ether.h>
+#include "prox_compat.h"
struct prox_cfg;
struct lcore_cfg;
@@ -58,8 +59,8 @@ void set_port_defaults(void);
TX_MBUF_SIZE is used for when transmitting only: in this case the mbuf size can be smaller.
*/
#define MBUF_SIZE (2048 + (unsigned)sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM + 2 * PROX_VLAN_TAG_SIZE)
-#define TX_MBUF_SIZE (ETHER_MAX_LEN + (unsigned)sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM + 2 * PROX_VLAN_TAG_SIZE)
+#define TX_MBUF_SIZE (PROX_RTE_ETHER_MAX_LEN + (unsigned)sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM + 2 * PROX_VLAN_TAG_SIZE)
-#define PROX_MTU ETHER_MAX_LEN - ETHER_HDR_LEN - ETHER_CRC_LEN
+#define PROX_MTU PROX_RTE_ETHER_MAX_LEN - PROX_RTE_ETHER_HDR_LEN - PROX_RTE_ETHER_CRC_LEN
#endif /* _DEFAULTS_H_ */
diff --git a/VNFs/DPPD-PROX/display.c b/VNFs/DPPD-PROX/display.c
index d7421e85..d81a40e4 100644
--- a/VNFs/DPPD-PROX/display.c
+++ b/VNFs/DPPD-PROX/display.c
@@ -1,5 +1,5 @@
/*
-// Copyright (c) 2010-2017 Intel Corporation
+// Copyright (c) 2010-2019 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -27,6 +27,7 @@
#include "display_ports.h"
#include "display_priority.h"
#include "display_irq.h"
+#include "display_latency_distr.h"
#include "display_rings.h"
#include "display_pkt_len.h"
#include "display_l4gen.h"
@@ -292,6 +293,9 @@ static void display_init_screens(void)
display_add_screen(display_ports());
display_add_screen(display_mempools());
display_add_screen(display_latency());
+#ifdef LATENCY_HISTOGRAM
+ display_add_screen(display_latency_distr());
+#endif
display_add_screen(display_rings());
display_add_screen(display_l4gen());
display_add_screen(display_pkt_len());
@@ -665,6 +669,7 @@ void display_end(void)
if (scr != NULL) {
endwin();
}
+ scr = NULL;
}
static void pps_print(WINDOW *dst_scr, int y, int x, uint64_t val, int is_blue)
@@ -917,6 +922,11 @@ void display_refresh(void)
stats_display_layout(1);
}
+void display_renew(void)
+{
+ stats_display_layout(0);
+}
+
void display_stats(void)
{
display_lock();
diff --git a/VNFs/DPPD-PROX/display.h b/VNFs/DPPD-PROX/display.h
index 4b517546..4c9f9ba7 100644
--- a/VNFs/DPPD-PROX/display.h
+++ b/VNFs/DPPD-PROX/display.h
@@ -1,5 +1,5 @@
/*
-// Copyright (c) 2010-2017 Intel Corporation
+// Copyright (c) 2010-2019 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -17,6 +17,7 @@
#ifndef _DISPLAY_H_
#define _DISPLAY_H_
+#define PROX_MAX_COLS 32
#include <inttypes.h>
#include <stdarg.h>
#include <stdio.h>
@@ -33,7 +34,7 @@ struct display_column {
};
struct display_table {
- struct display_column cols[16];
+ struct display_column cols[PROX_MAX_COLS];
char title[32];
int n_cols;
int offset;
@@ -86,6 +87,7 @@ void display_init(void);
void display_end(void);
void display_stats(void);
void display_refresh(void);
+void display_renew(void);
void display_print(const char *str);
void display_cmd(const char *cmd, int cmd_len, int cursor_pos);
void display_screen(unsigned screen_id);
diff --git a/VNFs/DPPD-PROX/display_latency_distr.c b/VNFs/DPPD-PROX/display_latency_distr.c
new file mode 100644
index 00000000..3e1cc38a
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_latency_distr.c
@@ -0,0 +1,190 @@
+/*
+// Copyright (c) 2019 Intel Corporation
+//
+// 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.
+*/
+
+#include <math.h>
+#include "handle_lat.h"
+#include "display_latency_distr.h"
+#include "stats_latency.h"
+#include "display.h"
+#include "lconf.h"
+
+static struct display_page display_page_latency_distr;
+static struct display_column *stats_latency_distr[LAT_BUCKET_COUNT];
+static struct display_column *stats_max;
+static struct display_column *core_col;
+static struct display_column *name_col;
+static uint32_t global_min_bucket_id = 0, global_max_bucket_id = LAT_BUCKET_COUNT - 1;
+static const uint16_t global_nb_buckets_displayed = 15;
+static uint32_t group_size = 9; //LAT_BUCKET_COUNT / global_nb_buckets_displayed;
+
+#define UNIT_INT(i) (((i) * bucket_unit_nsec)/1000)
+#define UNIT_FRACT(i) ((((i) * bucket_unit_nsec) % 1000) / 100)
+
+static void display_latency_distr_draw_frame(struct screen_state *state)
+{
+ uint32_t n_tasks = stats_get_n_latency();
+ struct lcore_cfg *lconf = NULL;
+ struct task_args *targ;
+ char name[32];
+ char *ptr;
+
+ display_page_init(&display_page_latency_distr);
+
+ struct display_table *core_name = display_page_add_table(&display_page_latency_distr);
+
+ display_table_init(core_name, "Core/task");
+ core_col = display_table_add_col(core_name);
+ name_col = display_table_add_col(core_name);
+ display_column_init(core_col, "Nb", 4);
+ display_column_init(name_col, "Name", 5);
+
+ uint32_t bucket_size = stats_get_latency_bucket_size();
+ struct display_table *stats = display_page_add_table(&display_page_latency_distr);
+ uint32_t bucket_unit_nsec = 1000000000 / (rte_get_tsc_hz() >> bucket_size);
+ if (state->toggle == 0) {
+ display_table_init(stats, "Statistics per second");
+ } else {
+ display_table_init(stats, "Total statistics");
+ }
+ char title[64];
+ stats_max = display_table_add_col(stats);
+ snprintf(title, sizeof(title), " MAXIMUM(mic)");
+ display_column_init(stats_max, title, 11);
+ plog_info("Bucket unit is %d nsec, bucket size is %d, freq is %ld\n", bucket_unit_nsec, bucket_size, rte_get_tsc_hz());
+
+ uint32_t i = global_min_bucket_id, first = i, k = 0;
+ while ((i < LAT_BUCKET_COUNT) && (i <= global_max_bucket_id)) {
+ stats_latency_distr[k] = display_table_add_col(stats);
+ if (i < LAT_BUCKET_COUNT - group_size) {
+ snprintf(title, sizeof(title), "%d.%01d-%d.%01d", UNIT_INT(i), UNIT_FRACT(i), UNIT_INT(i + group_size), UNIT_FRACT(i + group_size));
+ } else {
+ snprintf(title, sizeof(title), "> %d.%01d", UNIT_INT(i), UNIT_FRACT(i));
+ }
+ display_column_init(stats_latency_distr[k++], title, 9);
+ i += group_size;
+ }
+ display_page_draw_frame(&display_page_latency_distr, n_tasks);
+
+ uint32_t count = 0;
+ lconf = NULL;
+ while (core_targ_next(&lconf, &targ, 0) == 0) {
+ if (strcmp(targ->task_init->mode_str, "lat") == 0) {
+ display_column_print_core_task(core_col, count, lconf, targ);
+ if (targ->id == 0)
+ display_column_print(name_col, count, "%s", lconf->name);
+ count++;
+ }
+ }
+}
+
+static void display_latency_distr_draw_stats(struct screen_state *state)
+{
+ const uint32_t n_latency = stats_get_n_latency();
+ uint64_t *bucket;
+ uint32_t bucket_id = 0, min_bucket_id = LAT_BUCKET_COUNT - 1, max_bucket_id = 0;
+ struct time_unit tu;
+
+ for (uint32_t count = 0; count < n_latency; ++count) {
+ if (state->toggle == 0)
+ tu = stats_latency_get(count)->max.time;
+ else
+ tu = stats_latency_tot_get(count)->max.time;
+ display_column_print(stats_max, count, "%9lu.%03lu", tu.sec * 1000000 + tu.nsec / 1000, tu.nsec % 1000);
+ }
+
+ // Calculate min_bucket_id: id of 1st bucket with data for any tasks
+ // Calculate max_bucket_id: id of last bucket with data for any tasks
+ for (uint i = 0; i < LAT_BUCKET_COUNT; ++i) {
+ for (uint32_t count = 0; count < n_latency; ++count) {
+ if (state->toggle == 0)
+ bucket = stats_latency_get_bucket(count);
+ else
+ bucket = stats_latency_get_tot_bucket(count);
+ if (bucket[i] != 0) {
+ min_bucket_id = i;
+ break;
+ }
+ }
+ if (min_bucket_id != LAT_BUCKET_COUNT - 1)
+ break;
+ }
+
+ for (uint i = LAT_BUCKET_COUNT; i > 0; i--) {
+ for (uint32_t count = 0; count < n_latency; ++count) {
+ if (state->toggle == 0)
+ bucket = stats_latency_get_bucket(count);
+ else
+ bucket = stats_latency_get_tot_bucket(count);
+ if (bucket[i - 1] != 0) {
+ max_bucket_id = i - 1;
+ break;
+ }
+ }
+ if (max_bucket_id)
+ break;
+ }
+
+ if (max_bucket_id - min_bucket_id + 1 < global_nb_buckets_displayed) {
+ max_bucket_id = global_nb_buckets_displayed + min_bucket_id - 1;
+ }
+
+ if ((global_min_bucket_id != min_bucket_id) || (global_max_bucket_id != max_bucket_id)) {
+ global_min_bucket_id = min_bucket_id;
+ global_max_bucket_id = max_bucket_id;
+ // Calculate how many buckets must be grouped together
+ if (max_bucket_id - min_bucket_id + 1 > global_nb_buckets_displayed)
+ group_size = ceil(1.0 * (max_bucket_id - min_bucket_id + 1) / global_nb_buckets_displayed);
+ else
+ group_size = 1;
+ display_latency_distr_draw_frame(state);
+ display_renew();
+ plog_info("min_bucket_id = %d, max_bucket_id = %d\n", min_bucket_id, max_bucket_id);
+ }
+
+ for (uint32_t count = 0; count < n_latency; ++count) {
+ if (state->toggle == 0)
+ bucket = stats_latency_get_bucket(count);
+ else
+ bucket = stats_latency_get_tot_bucket(count);
+ uint32_t i = min_bucket_id, k = 0;
+ uint64_t nb = 0;
+ while ((i < LAT_BUCKET_COUNT) && (i <= global_max_bucket_id)){
+ for (uint32_t j = 0; j <= group_size; j++)
+ if (i + j < LAT_BUCKET_COUNT)
+ nb += bucket[i+j];
+ display_column_print(stats_latency_distr[k++], count, "%9lu", nb);
+ nb = 0;
+ i += group_size;
+ }
+ }
+}
+
+static int display_latency_distr_get_height(void)
+{
+ return stats_get_n_latency();
+}
+
+static struct display_screen display_screen_latency_distr = {
+ .draw_frame = display_latency_distr_draw_frame,
+ .draw_stats = display_latency_distr_draw_stats,
+ .get_height = display_latency_distr_get_height,
+ .title = "latency_distr",
+};
+
+struct display_screen *display_latency_distr(void)
+{
+ return &display_screen_latency_distr;
+}
diff --git a/VNFs/DPPD-PROX/display_latency_distr.h b/VNFs/DPPD-PROX/display_latency_distr.h
new file mode 100644
index 00000000..d22f16a4
--- /dev/null
+++ b/VNFs/DPPD-PROX/display_latency_distr.h
@@ -0,0 +1,23 @@
+/*
+// Copyright (c) 2019 Intel Corporation
+//
+// 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 DISPLAY_LATENCY_DISTR_H
+#define DISPLAY_LATENCY_DISTR_H
+
+struct display_screen;
+struct display_screen *display_latency_distr(void);
+
+#endif /* DISPLAY_LATENCY_DISTR_H */
diff --git a/VNFs/DPPD-PROX/genl4_stream.h b/VNFs/DPPD-PROX/genl4_stream.h
index b180765d..3f1b6c87 100644
--- a/VNFs/DPPD-PROX/genl4_stream.h
+++ b/VNFs/DPPD-PROX/genl4_stream.h
@@ -160,9 +160,9 @@ static void stream_ctx_reset_move(struct stream_ctx *ctx, struct stream_cfg *cfg
static int stream_cfg_calc_max_payload_len(struct stream_cfg *cfg, enum l4gen_peer peer)
{
const uint32_t l4_hdr_len = cfg->proto == IPPROTO_UDP?
- sizeof(struct udp_hdr) : sizeof(struct tcp_hdr);
+ sizeof(prox_rte_udp_hdr) : sizeof(prox_rte_tcp_hdr);
- return ETHER_MAX_LEN - ETHER_CRC_LEN - cfg->data[peer].hdr_len - l4_hdr_len;
+ return PROX_RTE_ETHER_MAX_LEN - PROX_RTE_ETHER_CRC_LEN - cfg->data[peer].hdr_len - l4_hdr_len;
}
static int stream_cfg_max_n_segments(struct stream_cfg *cfg)
diff --git a/VNFs/DPPD-PROX/genl4_stream_tcp.c b/VNFs/DPPD-PROX/genl4_stream_tcp.c
index e0cdb2b9..4d92546b 100644
--- a/VNFs/DPPD-PROX/genl4_stream_tcp.c
+++ b/VNFs/DPPD-PROX/genl4_stream_tcp.c
@@ -68,8 +68,8 @@ struct tcp_option {
void stream_tcp_create_rst(struct rte_mbuf *mbuf, struct l4_meta *l4_meta, struct pkt_tuple *tuple)
{
- struct tcp_hdr *tcp = (struct tcp_hdr *)l4_meta->l4_hdr;
- struct ipv4_hdr *ip = ((struct ipv4_hdr *)tcp) - 1;
+ prox_rte_tcp_hdr *tcp = (prox_rte_tcp_hdr *)l4_meta->l4_hdr;
+ prox_rte_ipv4_hdr *ip = ((prox_rte_ipv4_hdr *)tcp) - 1;
ip->src_addr = tuple->dst_addr;
ip->dst_addr = tuple->src_addr;
@@ -77,9 +77,9 @@ void stream_tcp_create_rst(struct rte_mbuf *mbuf, struct l4_meta *l4_meta, struc
tcp->dst_port = tuple->src_port;
tcp->src_port = tuple->dst_port;
- ip->total_length = rte_bswap16(sizeof(struct ipv4_hdr) + sizeof(struct tcp_hdr));
- tcp->tcp_flags = TCP_RST_FLAG;
- tcp->data_off = ((sizeof(struct tcp_hdr) / 4) << 4);
+ ip->total_length = rte_bswap16(sizeof(prox_rte_ipv4_hdr) + sizeof(prox_rte_tcp_hdr));
+ tcp->tcp_flags = PROX_RTE_TCP_RST_FLAG;
+ tcp->data_off = ((sizeof(prox_rte_tcp_hdr) / 4) << 4);
rte_pktmbuf_pkt_len(mbuf) = l4_meta->payload - rte_pktmbuf_mtod(mbuf, uint8_t *);
rte_pktmbuf_data_len(mbuf) = l4_meta->payload - rte_pktmbuf_mtod(mbuf, uint8_t *);
}
@@ -94,8 +94,8 @@ static void create_tcp_pkt(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint8_
pkt = rte_pktmbuf_mtod(mbuf, uint8_t *);
rte_memcpy(pkt, stream_cfg->data[act->peer].hdr, stream_cfg->data[act->peer].hdr_len);
- struct ipv4_hdr *l3_hdr = (struct ipv4_hdr*)&pkt[stream_cfg->data[act->peer].hdr_len - sizeof(struct ipv4_hdr)];
- struct tcp_hdr *l4_hdr = (struct tcp_hdr *)&pkt[stream_cfg->data[act->peer].hdr_len];
+ prox_rte_ipv4_hdr *l3_hdr = (prox_rte_ipv4_hdr*)&pkt[stream_cfg->data[act->peer].hdr_len - sizeof(prox_rte_ipv4_hdr)];
+ prox_rte_tcp_hdr *l4_hdr = (prox_rte_tcp_hdr *)&pkt[stream_cfg->data[act->peer].hdr_len];
l3_hdr->src_addr = ctx->tuple->dst_addr;
l3_hdr->dst_addr = ctx->tuple->src_addr;
@@ -104,17 +104,17 @@ static void create_tcp_pkt(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint8_
l4_hdr->src_port = ctx->tuple->dst_port;
l4_hdr->dst_port = ctx->tuple->src_port;
- uint32_t tcp_len = sizeof(struct tcp_hdr);
+ uint32_t tcp_len = sizeof(prox_rte_tcp_hdr);
uint32_t tcp_payload_len = 0;
uint32_t seq_len = 0;
struct tcp_option *tcp_op;
- if (tcp_flags & TCP_RST_FLAG) {
- tcp_flags |= TCP_RST_FLAG;
+ if (tcp_flags & PROX_RTE_TCP_RST_FLAG) {
+ tcp_flags |= PROX_RTE_TCP_RST_FLAG;
seq_len = 1;
}
- else if (tcp_flags & TCP_SYN_FLAG) {
- tcp_flags |= TCP_SYN_FLAG;
+ else if (tcp_flags & PROX_RTE_TCP_SYN_FLAG) {
+ tcp_flags |= PROX_RTE_TCP_SYN_FLAG;
/* Window scaling */
/* TODO: make options come from the stream. */
@@ -129,14 +129,14 @@ static void create_tcp_pkt(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint8_
ctx->seq_first_byte = ctx->ackd_seq + 1;
}
- else if (tcp_flags & TCP_FIN_FLAG) {
- tcp_flags |= TCP_FIN_FLAG;
+ else if (tcp_flags & PROX_RTE_TCP_FIN_FLAG) {
+ tcp_flags |= PROX_RTE_TCP_FIN_FLAG;
seq_len = 1;
}
- if (tcp_flags & TCP_ACK_FLAG) {
+ if (tcp_flags & PROX_RTE_TCP_ACK_FLAG) {
l4_hdr->recv_ack = rte_bswap32(ctx->recv_seq);
- tcp_flags |= TCP_ACK_FLAG;
+ tcp_flags |= PROX_RTE_TCP_ACK_FLAG;
}
else
l4_hdr->recv_ack = 0;
@@ -163,13 +163,13 @@ static void create_tcp_pkt(struct stream_ctx *ctx, struct rte_mbuf *mbuf, uint8_
rte_pktmbuf_pkt_len(mbuf) = l4_payload_offset + data_len;
rte_pktmbuf_data_len(mbuf) = l4_payload_offset + data_len;
- l3_hdr->total_length = rte_bswap16(sizeof(struct ipv4_hdr) + tcp_len + data_len);
+ l3_hdr->total_length = rte_bswap16(sizeof(prox_rte_ipv4_hdr) + tcp_len + data_len);
plogdx_dbg(mbuf, NULL);
plogx_dbg("put tcp packet with flags: %s%s%s, (len = %d, seq = %d, ack =%d)\n",
- tcp_flags & TCP_SYN_FLAG? "SYN ":"",
- tcp_flags & TCP_ACK_FLAG? "ACK ":"",
- tcp_flags & TCP_FIN_FLAG? "FIN ":"",
+ tcp_flags & PROX_RTE_TCP_SYN_FLAG? "SYN ":"",
+ tcp_flags & PROX_RTE_TCP_ACK_FLAG? "ACK ":"",
+ tcp_flags & PROX_RTE_TCP_FIN_FLAG? "FIN ":"",
data_len, rte_bswap32(l4_hdr->sent_seq), rte_bswap32(l4_hdr->recv_ack));
}
@@ -187,9 +187,9 @@ uint16_t stream_tcp_reply_len(struct stream_ctx *ctx)
the current implementation this packet
contains the TCP option field to set the
MSS. For this, add 4 bytes. */
- return ctx->stream_cfg->data[!ctx->peer].hdr_len + sizeof(struct tcp_hdr) + 4;
+ return ctx->stream_cfg->data[!ctx->peer].hdr_len + sizeof(prox_rte_tcp_hdr) + 4;
}
- return ctx->stream_cfg->data[!ctx->peer].hdr_len + sizeof(struct tcp_hdr);
+ return ctx->stream_cfg->data[!ctx->peer].hdr_len + sizeof(prox_rte_tcp_hdr);
}
else if (ctx->stream_cfg->actions[ctx->cur_action].peer == ctx->peer) {
/* The reply _could_ (due to races, still possibly
@@ -204,7 +204,7 @@ uint16_t stream_tcp_reply_len(struct stream_ctx *ctx)
if (remaining_len == 0) {
if (ctx->cur_action + 1 != ctx->stream_cfg->n_actions) {
if (ctx->stream_cfg->actions[ctx->cur_action + 1].peer == ctx->peer)
- return ctx->stream_cfg->data[ctx->peer].hdr_len + sizeof(struct tcp_hdr);
+ return ctx->stream_cfg->data[ctx->peer].hdr_len + sizeof(prox_rte_tcp_hdr);
else {
uint32_t seq_beg = ctx->recv_seq - ctx->other_seq_first_byte;
uint32_t end = ctx->stream_cfg->actions[ctx->cur_action + 1].beg +
@@ -212,15 +212,15 @@ uint16_t stream_tcp_reply_len(struct stream_ctx *ctx)
uint32_t remaining = end - seq_beg;
uint16_t data_len = remaining > 1460? 1460: remaining;
- return ctx->stream_cfg->data[!ctx->peer].hdr_len + sizeof(struct tcp_hdr) + data_len;
+ return ctx->stream_cfg->data[!ctx->peer].hdr_len + sizeof(prox_rte_tcp_hdr) + data_len;
}
}
else {
- return ctx->stream_cfg->data[ctx->peer].hdr_len + sizeof(struct tcp_hdr);
+ return ctx->stream_cfg->data[ctx->peer].hdr_len + sizeof(prox_rte_tcp_hdr);
}
}
else {
- return ctx->stream_cfg->data[ctx->peer].hdr_len + sizeof(struct tcp_hdr);
+ return ctx->stream_cfg->data[ctx->peer].hdr_len + sizeof(prox_rte_tcp_hdr);
}
}
else if (ctx->stream_cfg->actions[ctx->cur_action].peer != ctx->peer) {
@@ -230,10 +230,10 @@ uint16_t stream_tcp_reply_len(struct stream_ctx *ctx)
uint32_t remaining = end - seq_beg;
uint16_t data_len = remaining > 1460? 1460: remaining;
- return ctx->stream_cfg->data[!ctx->peer].hdr_len + sizeof(struct tcp_hdr) + data_len;
+ return ctx->stream_cfg->data[!ctx->peer].hdr_len + sizeof(prox_rte_tcp_hdr) + data_len;
}
else
- return ctx->stream_cfg->data[ctx->peer].hdr_len + sizeof(struct tcp_hdr);
+ return ctx->stream_cfg->data[ctx->peer].hdr_len + sizeof(prox_rte_tcp_hdr);
}
static void stream_tcp_proc_in_order_data(struct stream_ctx *ctx, struct l4_meta *l4_meta, int *progress_seq)
@@ -294,18 +294,18 @@ static void stream_tcp_proc_in_order_data(struct stream_ctx *ctx, struct l4_meta
static int stream_tcp_proc_in(struct stream_ctx *ctx, struct l4_meta *l4_meta)
{
- struct tcp_hdr *tcp = NULL;
+ prox_rte_tcp_hdr *tcp = NULL;
int got_syn = 0;
int got_ack = 0;
int got_fin = 0;
int got_rst = 0;
- tcp = (struct tcp_hdr *)l4_meta->l4_hdr;
+ tcp = (prox_rte_tcp_hdr *)l4_meta->l4_hdr;
- got_syn = tcp->tcp_flags & TCP_SYN_FLAG;
- got_ack = tcp->tcp_flags & TCP_ACK_FLAG;
- got_fin = tcp->tcp_flags & TCP_FIN_FLAG;
- got_rst = tcp->tcp_flags & TCP_RST_FLAG;
+ got_syn = tcp->tcp_flags & PROX_RTE_TCP_SYN_FLAG;
+ got_ack = tcp->tcp_flags & PROX_RTE_TCP_ACK_FLAG;
+ got_fin = tcp->tcp_flags & PROX_RTE_TCP_FIN_FLAG;
+ got_rst = tcp->tcp_flags & PROX_RTE_TCP_RST_FLAG;
plogx_dbg("TCP, flags: %s%s%s, (len = %d, seq = %d, ack =%d)\n", got_syn? "SYN ":"", got_ack? "ACK ":"", got_fin? "FIN " : "", l4_meta->len, rte_bswap32(tcp->sent_seq), rte_bswap32(tcp->recv_ack));
if (got_syn)
@@ -400,7 +400,7 @@ static int stream_tcp_proc_in(struct stream_ctx *ctx, struct l4_meta *l4_meta)
}
/* parse options */
- if (((tcp->data_off >> 4)*4) > sizeof(struct tcp_hdr)) {
+ if (((tcp->data_off >> 4)*4) > sizeof(prox_rte_tcp_hdr)) {
struct tcp_option *tcp_op = (struct tcp_option *)(tcp + 1);
uint8_t *payload = (uint8_t *)tcp + ((tcp->data_off >> 4)*4);
@@ -440,7 +440,7 @@ static int stream_tcp_proc_out_closed(struct stream_ctx *ctx, struct rte_mbuf *m
ctx->next_seq = 99;
ctx->ackd_seq = 99;
- create_tcp_pkt(ctx, mbuf, TCP_SYN_FLAG, 0, 0);
+ create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_SYN_FLAG, 0, 0);
token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
*next_tsc = tcp_retx_timeout(ctx);
return 0;
@@ -461,7 +461,7 @@ static int stream_tcp_proc_out_listen(struct stream_ctx *ctx, struct rte_mbuf *m
pkt_tuple_debug(ctx->tuple);
ctx->flags |= STREAM_CTX_F_TCP_ENDED;
- create_tcp_pkt(ctx, mbuf, TCP_RST_FLAG, 0, 0);
+ create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_RST_FLAG, 0, 0);
token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
*next_tsc = tcp_retx_timeout(ctx);
return 0;
@@ -475,7 +475,7 @@ static int stream_tcp_proc_out_listen(struct stream_ctx *ctx, struct rte_mbuf *m
ctx->tcp_state = SYN_RECEIVED;
- create_tcp_pkt(ctx, mbuf, TCP_SYN_FLAG | TCP_ACK_FLAG, 0, 0);
+ create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_SYN_FLAG | PROX_RTE_TCP_ACK_FLAG, 0, 0);
token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
*next_tsc = tcp_retx_timeout(ctx);
return 0;
@@ -517,7 +517,7 @@ static int stream_tcp_proc_out_syn_sent(struct stream_ctx *ctx, struct rte_mbuf
return -1;
}
else {
- create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG, 0, 0);
+ create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_ACK_FLAG, 0, 0);
token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
*next_tsc = tcp_retx_timeout(ctx);
}
@@ -542,7 +542,7 @@ static int stream_tcp_proc_out_syn_recv(struct stream_ctx *ctx, struct rte_mbuf
ctx->same_state = 0;
ctx->tcp_state = ESTABLISHED;
if (ctx->stream_cfg->actions[ctx->cur_action].peer != ctx->peer) {
- create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG, 0, 0);
+ create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_ACK_FLAG, 0, 0);
token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
*next_tsc = tcp_retx_timeout(ctx);
return 0;
@@ -562,7 +562,7 @@ static int stream_tcp_proc_out_syn_recv(struct stream_ctx *ctx, struct rte_mbuf
data.
*/
- /* create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG, 0, 0); */
+ /* create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_ACK_FLAG, 0, 0); */
/* token_time_take(&ctx->token_time, mbuf_wire_size(mbuf)); */
*next_tsc = tcp_resched_timeout(ctx);
return -1;
@@ -576,7 +576,7 @@ static int stream_tcp_proc_out_syn_recv(struct stream_ctx *ctx, struct rte_mbuf
++ctx->same_state;
tcp_set_retransmit(ctx);
ctx->next_seq = ctx->ackd_seq;
- create_tcp_pkt(ctx, mbuf, TCP_SYN_FLAG | TCP_ACK_FLAG, 0, 0);
+ create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_SYN_FLAG | PROX_RTE_TCP_ACK_FLAG, 0, 0);
token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
*next_tsc = tcp_retx_timeout(ctx);
return 0;
@@ -603,7 +603,7 @@ static int stream_tcp_proc_out_estab_tx(struct stream_ctx *ctx, struct rte_mbuf
plogx_dbg("Moving to FIN_WAIT\n");
ctx->tcp_state = FIN_WAIT;
ctx->same_state = 0;
- create_tcp_pkt(ctx, mbuf, TCP_FIN_FLAG | TCP_ACK_FLAG, 0, 0);
+ create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_FIN_FLAG | PROX_RTE_TCP_ACK_FLAG, 0, 0);
token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
*next_tsc = tcp_retx_timeout(ctx);
return 0;
@@ -682,7 +682,7 @@ static int stream_tcp_proc_out_estab_tx(struct stream_ctx *ctx, struct rte_mbuf
else
ctx->flags &= ~STREAM_CTX_F_MORE_DATA;
- create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG, data_beg, data_len);
+ create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_ACK_FLAG, data_beg, data_len);
token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
if (ctx->flags & STREAM_CTX_F_MORE_DATA)
*next_tsc = tcp_resched_timeout(ctx);
@@ -705,14 +705,14 @@ static int stream_tcp_proc_out_estab_rx(struct stream_ctx *ctx, struct rte_mbuf
plogx_dbg("Got fin!\n");
if (1) {
ctx->tcp_state = LAST_ACK;
- create_tcp_pkt(ctx, mbuf, TCP_FIN_FLAG | TCP_ACK_FLAG, 0, 0);
+ create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_FIN_FLAG | PROX_RTE_TCP_ACK_FLAG, 0, 0);
token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
*next_tsc = tcp_retx_timeout(ctx);
return 0;
}
else {
ctx->tcp_state = CLOSE_WAIT;
- create_tcp_pkt(ctx, mbuf, TCP_FIN_FLAG, 0, 0);
+ create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_FIN_FLAG, 0, 0);
token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
*next_tsc = tcp_resched_timeout(ctx);
return 0;
@@ -727,7 +727,7 @@ static int stream_tcp_proc_out_estab_rx(struct stream_ctx *ctx, struct rte_mbuf
plogx_dbg("state++ (ack = %d)\n", ctx->recv_seq);
}
- create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG, 0, 0);
+ create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_ACK_FLAG, 0, 0);
token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
*next_tsc = tcp_retx_timeout(ctx);
return 0;
@@ -756,7 +756,7 @@ static int stream_tcp_proc_out_close_wait(struct stream_ctx *ctx, struct rte_mbu
when the FIN is sent after ACK'ing the incoming FIN. In any
case, it does not matter if there was a packet or not. */
ctx->tcp_state = LAST_ACK;
- create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG | TCP_FIN_FLAG, 0, 0);
+ create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_ACK_FLAG | PROX_RTE_TCP_FIN_FLAG, 0, 0);
token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
*next_tsc = tcp_retx_timeout(ctx);
return 0;
@@ -786,7 +786,7 @@ static int stream_tcp_proc_out_last_ack(struct stream_ctx *ctx, struct rte_mbuf
ctx->next_seq = ctx->ackd_seq;
ctx->same_state++;
tcp_set_retransmit(ctx);
- create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG | TCP_FIN_FLAG, 0, 0);
+ create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_ACK_FLAG | PROX_RTE_TCP_FIN_FLAG, 0, 0);
token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
*next_tsc = tcp_retx_timeout(ctx);
return 0;
@@ -808,7 +808,7 @@ static int stream_tcp_proc_out_fin_wait(struct stream_ctx *ctx, struct rte_mbuf
ctx->tcp_state = TIME_WAIT;
ctx->sched_tsc = rte_rdtsc() + ctx->stream_cfg->tsc_timeout_time_wait;
plogx_dbg("from FIN_WAIT to TIME_WAIT\n");
- create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG, 0, 0);
+ create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_ACK_FLAG, 0, 0);
token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
*next_tsc = ctx->stream_cfg->tsc_timeout_time_wait;
return 0;
@@ -830,7 +830,7 @@ static int stream_tcp_proc_out_fin_wait(struct stream_ctx *ctx, struct rte_mbuf
ctx->same_state++;
tcp_set_retransmit(ctx);
ctx->next_seq = ctx->ackd_seq;
- create_tcp_pkt(ctx, mbuf, TCP_FIN_FLAG | TCP_ACK_FLAG, 0, 0);
+ create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_FIN_FLAG | PROX_RTE_TCP_ACK_FLAG, 0, 0);
token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
*next_tsc = tcp_retx_timeout(ctx);
return 0;
@@ -853,7 +853,7 @@ static int stream_tcp_proc_out_time_wait(struct stream_ctx *ctx, struct rte_mbuf
plogx_dbg("Got packet while in TIME_WAIT (pkt ACK reTX)\n");
ctx->sched_tsc = rte_rdtsc() + ctx->stream_cfg->tsc_timeout_time_wait;
- create_tcp_pkt(ctx, mbuf, TCP_ACK_FLAG, 0, 0);
+ create_tcp_pkt(ctx, mbuf, PROX_RTE_TCP_ACK_FLAG, 0, 0);
token_time_take(&ctx->token_time, mbuf_wire_size(mbuf));
*next_tsc = ctx->stream_cfg->tsc_timeout_time_wait;
return 0;
@@ -917,7 +917,7 @@ int stream_tcp_is_ended(struct stream_ctx *ctx)
static void add_pkt_bytes(uint32_t *n_pkts, uint32_t *n_bytes, uint32_t len)
{
- len = (len < 60? 60 : len) + 20 + ETHER_CRC_LEN;
+ len = (len < 60? 60 : len) + 20 + PROX_RTE_ETHER_CRC_LEN;
(*n_pkts)++;
*n_bytes += len;
@@ -932,9 +932,9 @@ void stream_tcp_calc_len(struct stream_cfg *cfg, uint32_t *n_pkts, uint32_t *n_b
*n_bytes = 0;
/* Connection setup */
- add_pkt_bytes(n_pkts, n_bytes, client_hdr_len + sizeof(struct tcp_hdr) + 4); /* SYN */
- add_pkt_bytes(n_pkts, n_bytes, server_hdr_len + sizeof(struct tcp_hdr) + 4); /* SYN/ACK */
- add_pkt_bytes(n_pkts, n_bytes, client_hdr_len + sizeof(struct tcp_hdr)); /* ACK */
+ add_pkt_bytes(n_pkts, n_bytes, client_hdr_len + sizeof(prox_rte_tcp_hdr) + 4); /* SYN */
+ add_pkt_bytes(n_pkts, n_bytes, server_hdr_len + sizeof(prox_rte_tcp_hdr) + 4); /* SYN/ACK */
+ add_pkt_bytes(n_pkts, n_bytes, client_hdr_len + sizeof(prox_rte_tcp_hdr)); /* ACK */
for (uint32_t i = 0; i < cfg->n_actions; ++i) {
const uint32_t mss = 1440; /* TODO: should come from peer's own mss. */
@@ -947,11 +947,11 @@ void stream_tcp_calc_len(struct stream_cfg *cfg, uint32_t *n_pkts, uint32_t *n_b
while (remaining) {
uint32_t seg = remaining > mss? mss: remaining;
- add_pkt_bytes(n_pkts, n_bytes, send_hdr_len + sizeof(struct tcp_hdr) + seg);
+ add_pkt_bytes(n_pkts, n_bytes, send_hdr_len + sizeof(prox_rte_tcp_hdr) + seg);
remaining -= seg;
}
- add_pkt_bytes(n_pkts, n_bytes, reply_hdr_len + sizeof(struct tcp_hdr));
+ add_pkt_bytes(n_pkts, n_bytes, reply_hdr_len + sizeof(prox_rte_tcp_hdr));
}
/* Connection Tear-down */
@@ -960,7 +960,7 @@ void stream_tcp_calc_len(struct stream_cfg *cfg, uint32_t *n_pkts, uint32_t *n_b
const uint32_t init_hdr_len = last_peer == PEER_CLIENT? client_hdr_len : server_hdr_len;
const uint32_t resp_hdr_len = last_peer == PEER_CLIENT? server_hdr_len : client_hdr_len;
- add_pkt_bytes(n_pkts, n_bytes, init_hdr_len + sizeof(struct tcp_hdr)); /* FIN */
- add_pkt_bytes(n_pkts, n_bytes, resp_hdr_len + sizeof(struct tcp_hdr)); /* FIN/ACK */
- add_pkt_bytes(n_pkts, n_bytes, init_hdr_len + sizeof(struct tcp_hdr)); /* ACK */
+ add_pkt_bytes(n_pkts, n_bytes, init_hdr_len + sizeof(prox_rte_tcp_hdr)); /* FIN */
+ add_pkt_bytes(n_pkts, n_bytes, resp_hdr_len + sizeof(prox_rte_tcp_hdr)); /* FIN/ACK */
+ add_pkt_bytes(n_pkts, n_bytes, init_hdr_len + sizeof(prox_rte_tcp_hdr)); /* ACK */
}
diff --git a/VNFs/DPPD-PROX/genl4_stream_udp.c b/VNFs/DPPD-PROX/genl4_stream_udp.c
index 3de2db09..31661682 100644
--- a/VNFs/DPPD-PROX/genl4_stream_udp.c
+++ b/VNFs/DPPD-PROX/genl4_stream_udp.c
@@ -93,7 +93,7 @@ int stream_udp_proc(struct stream_ctx *ctx, struct rte_mbuf *mbuf, struct l4_met
uint8_t *pkt = rte_pktmbuf_mtod(mbuf, uint8_t *);
const struct peer_action *act = &stream_cfg->actions[ctx->cur_action];
- uint16_t pkt_len = stream_cfg->data[act->peer].hdr_len + sizeof(struct udp_hdr) + act->len;
+ uint16_t pkt_len = stream_cfg->data[act->peer].hdr_len + sizeof(prox_rte_udp_hdr) + act->len;
rte_pktmbuf_pkt_len(mbuf) = pkt_len;
rte_pktmbuf_data_len(mbuf) = pkt_len;
@@ -101,19 +101,19 @@ int stream_udp_proc(struct stream_ctx *ctx, struct rte_mbuf *mbuf, struct l4_met
/* Construct the packet. The template is used up to L4 header,
a gap of sizeof(l4_hdr) is skipped, followed by the payload. */
rte_memcpy(pkt, stream_cfg->data[act->peer].hdr, stream_cfg->data[act->peer].hdr_len);
- rte_memcpy(pkt + stream_cfg->data[act->peer].hdr_len + sizeof(struct udp_hdr), stream_cfg->data[act->peer].content + act->beg, act->len);
+ rte_memcpy(pkt + stream_cfg->data[act->peer].hdr_len + sizeof(prox_rte_udp_hdr), stream_cfg->data[act->peer].content + act->beg, act->len);
- struct ipv4_hdr *l3_hdr = (struct ipv4_hdr*)&pkt[stream_cfg->data[act->peer].hdr_len - sizeof(struct ipv4_hdr)];
- struct udp_hdr *l4_hdr = (struct udp_hdr*)&pkt[stream_cfg->data[act->peer].hdr_len];
+ prox_rte_ipv4_hdr *l3_hdr = (prox_rte_ipv4_hdr*)&pkt[stream_cfg->data[act->peer].hdr_len - sizeof(prox_rte_ipv4_hdr)];
+ prox_rte_udp_hdr *l4_hdr = (prox_rte_udp_hdr*)&pkt[stream_cfg->data[act->peer].hdr_len];
l3_hdr->src_addr = ctx->tuple->dst_addr;
l3_hdr->dst_addr = ctx->tuple->src_addr;
l3_hdr->next_proto_id = IPPROTO_UDP;
l4_hdr->src_port = ctx->tuple->dst_port;
l4_hdr->dst_port = ctx->tuple->src_port;
- l4_hdr->dgram_len = rte_bswap16(sizeof(struct udp_hdr) + act->len);
+ l4_hdr->dgram_len = rte_bswap16(sizeof(prox_rte_udp_hdr) + act->len);
/* TODO: UDP checksum calculation */
- l3_hdr->total_length = rte_bswap16(sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr) + act->len);
+ l3_hdr->total_length = rte_bswap16(sizeof(prox_rte_ipv4_hdr) + sizeof(prox_rte_udp_hdr) + act->len);
ctx->cur_pos[ctx->peer] += act->len;
ctx->cur_action++;
@@ -144,7 +144,7 @@ uint16_t stream_udp_reply_len(struct stream_ctx *ctx)
else if (ctx->stream_cfg->actions[ctx->cur_action].peer == ctx->peer)
return 0;
else
- return ctx->stream_cfg->data[ctx->stream_cfg->actions[ctx->cur_action].peer].hdr_len + sizeof(struct udp_hdr) +
+ return ctx->stream_cfg->data[ctx->stream_cfg->actions[ctx->cur_action].peer].hdr_len + sizeof(prox_rte_udp_hdr) +
ctx->stream_cfg->actions[ctx->cur_action].len;
}
@@ -158,7 +158,7 @@ void stream_udp_calc_len(struct stream_cfg *cfg, uint32_t *n_pkts, uint32_t *n_b
for (uint32_t i = 0; i < cfg->n_actions; ++i) {
const uint32_t send_hdr_len = cfg->actions[i].peer == PEER_CLIENT? client_hdr_len : server_hdr_len;
- uint32_t len = send_hdr_len + sizeof(struct udp_hdr) + cfg->actions[i].len;
+ uint32_t len = send_hdr_len + sizeof(prox_rte_udp_hdr) + cfg->actions[i].len;
*n_bytes += (len < 60? 60 : len) + 24;
(*n_pkts)++;
}
diff --git a/VNFs/DPPD-PROX/handle_aggregator.c b/VNFs/DPPD-PROX/handle_aggregator.c
index 6434d759..ccf8b8cc 100644
--- a/VNFs/DPPD-PROX/handle_aggregator.c
+++ b/VNFs/DPPD-PROX/handle_aggregator.c
@@ -44,10 +44,10 @@
(stats)->rx_prio[prio] += ntx; \
} while(0) \
-static inline uint8_t detect_l4_priority(uint8_t l3_priority, const struct ipv4_hdr *ipv4_hdr)
+static inline uint8_t detect_l4_priority(uint8_t l3_priority, const prox_rte_ipv4_hdr *ipv4_hdr)
{
if (ipv4_hdr->next_proto_id == IPPROTO_UDP) {
- const struct udp_hdr *udp = (const struct udp_hdr *)((const uint8_t *)ipv4_hdr + sizeof(struct ipv4_hdr));
+ const prox_rte_udp_hdr *udp = (const prox_rte_udp_hdr *)((const uint8_t *)ipv4_hdr + sizeof(prox_rte_ipv4_hdr));
if (((udp->src_port == 0x67) && (udp->dst_port == 0x68)) || ((udp->src_port == 0x68) && (udp->dst_port == 0x67))) {
return PRIORITY_DHCP;
}
@@ -55,7 +55,7 @@ static inline uint8_t detect_l4_priority(uint8_t l3_priority, const struct ipv4_
return l3_priority;
}
-static inline uint8_t detect_l3_priority(uint8_t l2_priority, const struct ipv4_hdr *ipv4_hdr)
+static inline uint8_t detect_l3_priority(uint8_t l2_priority, const prox_rte_ipv4_hdr *ipv4_hdr)
{
uint8_t dscp;
if ((ipv4_hdr->version_ihl >> 4) == 4) {
@@ -107,10 +107,10 @@ static inline void buffer_packet(struct task_aggregator *task, struct rte_mbuf *
static inline void handle_aggregator(struct task_aggregator *task, struct rte_mbuf *mbuf)
{
- struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
uint8_t priority = 0;
const struct qinq_hdr *pqinq;
- const struct ipv4_hdr *ipv4_hdr;
+ const prox_rte_ipv4_hdr *ipv4_hdr;
const uint16_t eth_type = peth->ether_type;
switch (eth_type) {
@@ -121,7 +121,7 @@ static inline void handle_aggregator(struct task_aggregator *task, struct rte_mb
pqinq = rte_pktmbuf_mtod(mbuf, const struct qinq_hdr *);
if ((priority = detect_l2_priority(pqinq)) == OUT_DISCARD)
break;
- ipv4_hdr = (const struct ipv4_hdr *)(pqinq + 1);
+ ipv4_hdr = (const prox_rte_ipv4_hdr *)(pqinq + 1);
if ((priority = detect_l3_priority(priority, ipv4_hdr)) == OUT_DISCARD)
break;
if ((priority = detect_l4_priority(priority, ipv4_hdr)) == OUT_DISCARD)
@@ -130,7 +130,7 @@ static inline void handle_aggregator(struct task_aggregator *task, struct rte_mb
case ETYPE_VLAN:
break;
case ETYPE_IPv4:
- ipv4_hdr = (const struct ipv4_hdr *)(peth+1);
+ ipv4_hdr = (const prox_rte_ipv4_hdr *)(peth+1);
if ((priority = detect_l3_priority(LOW_PRIORITY, ipv4_hdr)) == OUT_DISCARD)
break;
if ((priority = detect_l4_priority(priority, ipv4_hdr)) == OUT_DISCARD)
diff --git a/VNFs/DPPD-PROX/handle_arp.c b/VNFs/DPPD-PROX/handle_arp.c
index 767cee11..2da98ef2 100644
--- a/VNFs/DPPD-PROX/handle_arp.c
+++ b/VNFs/DPPD-PROX/handle_arp.c
@@ -28,7 +28,7 @@
struct task_arp {
struct task_base base;
- struct ether_addr src_mac;
+ prox_rte_ether_addr src_mac;
uint32_t seed;
uint32_t flags;
uint32_t ip;
@@ -44,7 +44,7 @@ static void task_update_config(struct task_arp *task)
task->ip = task->tmp_ip;
}
-static void handle_arp(struct task_arp *task, struct ether_hdr_arp *hdr, struct ether_addr *s_addr)
+static void handle_arp(struct task_arp *task, struct ether_hdr_arp *hdr, prox_rte_ether_addr *s_addr)
{
build_arp_reply(hdr, s_addr);
}
@@ -56,7 +56,7 @@ static int handle_arp_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uin
uint8_t out[MAX_PKT_BURST] = {0};
struct rte_mbuf *replies_mbufs[64] = {0}, *arp_pkt_mbufs[64] = {0};
int n_arp_reply_pkts = 0, n_other_pkts = 0,n_arp_pkts = 0;
- struct ether_addr s_addr;
+ prox_rte_ether_addr s_addr;
for (uint16_t j = 0; j < n_pkts; ++j) {
hdr = rte_pktmbuf_mtod(mbufs[j], struct ether_hdr_arp *);
@@ -130,7 +130,7 @@ static void init_task_arp(struct task_base *tbase, struct task_args *targ)
task->arp_replies_ring = OUT_DISCARD;
task->seed = rte_rdtsc();
- memcpy(&task->src_mac, &prox_port_cfg[task->base.tx_params_hw_sw.tx_port_queue.port].eth_addr, sizeof(struct ether_addr));
+ memcpy(&task->src_mac, &prox_port_cfg[task->base.tx_params_hw_sw.tx_port_queue.port].eth_addr, sizeof(prox_rte_ether_addr));
task->ip = rte_cpu_to_be_32(targ->local_ipv4);
task->tmp_ip = task->ip;
diff --git a/VNFs/DPPD-PROX/handle_blockudp.c b/VNFs/DPPD-PROX/handle_blockudp.c
index 04c945e5..8dbfea8a 100644
--- a/VNFs/DPPD-PROX/handle_blockudp.c
+++ b/VNFs/DPPD-PROX/handle_blockudp.c
@@ -35,8 +35,8 @@ static int handle_blockudp_bulk(struct task_base *tbase, struct rte_mbuf **mbufs
uint16_t j;
for (j = 0; j < n_pkts; ++j) {
- struct ether_hdr *peth = rte_pktmbuf_mtod(mbufs[j], struct ether_hdr *);
- struct ipv4_hdr *pip = (struct ipv4_hdr *) (peth + 1);
+ prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbufs[j], prox_rte_ether_hdr *);
+ prox_rte_ipv4_hdr *pip = (prox_rte_ipv4_hdr *) (peth + 1);
out[j] = peth->ether_type == ETYPE_IPv4 && pip->next_proto_id == 0x11 ? OUT_DISCARD : 0;
}
diff --git a/VNFs/DPPD-PROX/handle_cgnat.c b/VNFs/DPPD-PROX/handle_cgnat.c
index 0aa6876f..f516921c 100644
--- a/VNFs/DPPD-PROX/handle_cgnat.c
+++ b/VNFs/DPPD-PROX/handle_cgnat.c
@@ -111,9 +111,9 @@ struct task_nat {
static __m128i proto_ipsrc_portsrc_mask;
static __m128i proto_ipdst_portdst_mask;
struct pkt_eth_ipv4 {
- struct ether_hdr ether_hdr;
- struct ipv4_hdr ipv4_hdr;
- struct udp_hdr udp_hdr;
+ prox_rte_ether_hdr ether_hdr;
+ prox_rte_ipv4_hdr ipv4_hdr;
+ prox_rte_udp_hdr udp_hdr;
} __attribute__((packed));
void task_cgnat_dump_public_hash(struct task_nat *task)
@@ -128,7 +128,7 @@ void task_cgnat_dump_private_hash(struct task_nat *task)
static void set_l2(struct task_nat *task, struct rte_mbuf *mbuf, uint8_t nh_idx)
{
- struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
*((uint64_t *)(&peth->d_addr)) = task->next_hops[nh_idx].mac_port_8bytes;
*((uint64_t *)(&peth->s_addr)) = task->src_mac[task->next_hops[nh_idx].mac_port.out_idx];
}
@@ -136,8 +136,8 @@ static void set_l2(struct task_nat *task, struct rte_mbuf *mbuf, uint8_t nh_idx)
static uint8_t route_ipv4(struct task_nat *task, struct rte_mbuf *mbuf)
{
struct pkt_eth_ipv4 *pkt = rte_pktmbuf_mtod(mbuf, struct pkt_eth_ipv4 *);
- struct ipv4_hdr *ip = &pkt->ipv4_hdr;
- struct ether_hdr *peth_out;
+ prox_rte_ipv4_hdr *ip = &pkt->ipv4_hdr;
+ prox_rte_ether_hdr *peth_out;
uint8_t tx_port;
uint32_t dst_ip;
@@ -394,7 +394,7 @@ static int handle_nat_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uin
private_ip_idx = task->private_flow_entries[port_idx].private_ip_idx;
if (task->private_ip_info[private_ip_idx].mac_aging_time + tsc_hz < tsc)
task->private_ip_info[private_ip_idx].mac_aging_time = tsc;
- prox_ip_udp_cksum(mbufs[j], &pkt[j]->ipv4_hdr, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+ prox_ip_udp_cksum(mbufs[j], &pkt[j]->ipv4_hdr, sizeof(prox_rte_ether_hdr), sizeof(prox_rte_ipv4_hdr), task->offload_crc);
out[j] = route_ipv4(task, mbufs[j]);
}
}
@@ -486,7 +486,7 @@ static int handle_nat_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uin
}
if (task->private_ip_info[private_ip_idx].mac_aging_time + tsc_hz < tsc)
task->private_ip_info[private_ip_idx].mac_aging_time = tsc;
- prox_ip_udp_cksum(mbufs[j], &pkt[j]->ipv4_hdr, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+ prox_ip_udp_cksum(mbufs[j], &pkt[j]->ipv4_hdr, sizeof(prox_rte_ether_hdr), sizeof(prox_rte_ipv4_hdr), task->offload_crc);
// TODO: if route fails while just added new key in table, should we delete the key from the table?
out[j] = route_ipv4(task, mbufs[j]);
if (out[j] && new_entry) {
@@ -532,7 +532,7 @@ static int handle_nat_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uin
rte_memcpy(((uint8_t *)(pkt[j])) + 6, &task->src_mac_from_dpdk_port[task->public_entries[port_idx].dpdk_port], 6);
out[j] = task->public_entries[port_idx].dpdk_port;
}
- prox_ip_udp_cksum(mbufs[j], &pkt[j]->ipv4_hdr, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+ prox_ip_udp_cksum(mbufs[j], &pkt[j]->ipv4_hdr, sizeof(prox_rte_ether_hdr), sizeof(prox_rte_ipv4_hdr), task->offload_crc);
}
return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
}
diff --git a/VNFs/DPPD-PROX/handle_classify.c b/VNFs/DPPD-PROX/handle_classify.c
index 59b9b266..96a14149 100644
--- a/VNFs/DPPD-PROX/handle_classify.c
+++ b/VNFs/DPPD-PROX/handle_classify.c
@@ -61,7 +61,7 @@ static inline void handle_classify(struct task_classify *task, struct rte_mbuf *
prev_tc = sched->traffic_class;
#endif
- const struct ipv4_hdr *ipv4_hdr = (const struct ipv4_hdr *)(pqinq + 1);
+ const prox_rte_ipv4_hdr *ipv4_hdr = (const prox_rte_ipv4_hdr *)(pqinq + 1);
uint8_t dscp = task->dscp[ipv4_hdr->type_of_service >> 2];
uint8_t queue = dscp & 0x3;
diff --git a/VNFs/DPPD-PROX/handle_esp.c b/VNFs/DPPD-PROX/handle_esp.c
index 31969de3..447fcfa2 100644
--- a/VNFs/DPPD-PROX/handle_esp.c
+++ b/VNFs/DPPD-PROX/handle_esp.c
@@ -62,9 +62,9 @@ struct task_esp_enc {
uint8_t cdev_id;
uint16_t qp_id;
uint32_t local_ipv4;
- struct ether_addr local_mac;
+ prox_rte_ether_addr local_mac;
uint32_t remote_ipv4;
- struct ether_addr dst_mac;
+ prox_rte_ether_addr dst_mac;
struct rte_mempool *crypto_op_pool;
struct rte_mempool *session_pool;
struct rte_cryptodev_sym_session *sess;
@@ -76,8 +76,8 @@ struct task_esp_dec {
uint8_t cdev_id;
uint16_t qp_id;
uint32_t local_ipv4;
- struct ether_addr local_mac;
- struct ether_addr dst_mac;
+ prox_rte_ether_addr local_mac;
+ prox_rte_ether_addr dst_mac;
struct rte_mempool *crypto_op_pool;
struct rte_mempool *session_pool;
struct rte_cryptodev_sym_session *sess;
@@ -242,14 +242,14 @@ static void init_task_esp_enc(struct task_base *tbase, struct task_args *targ)
task->local_ipv4 = rte_cpu_to_be_32(targ->local_ipv4);
task->remote_ipv4 = rte_cpu_to_be_32(targ->remote_ipv4);
- //memcpy(&task->src_mac, &prox_port_cfg[task->base.tx_params_hw.tx_port_queue->port].eth_addr, sizeof(struct ether_addr));
+ //memcpy(&task->src_mac, &prox_port_cfg[task->base.tx_params_hw.tx_port_queue->port].eth_addr, sizeof(prox_rte_ether_addr));
struct prox_port_cfg *port = find_reachable_port(targ);
- memcpy(&task->local_mac, &port->eth_addr, sizeof(struct ether_addr));
+ memcpy(&task->local_mac, &port->eth_addr, sizeof(prox_rte_ether_addr));
if (targ->flags & TASK_ARG_DST_MAC_SET){
memcpy(&task->dst_mac, &targ->edaddr, sizeof(task->dst_mac));
plog_info("TASK_ARG_DST_MAC_SET ("MAC_BYTES_FMT")\n", MAC_BYTES(task->dst_mac.addr_bytes));
- //ether_addr_copy(&ptask->dst_mac, &peth->d_addr);
+ //prox_rte_ether_addr_copy(&ptask->dst_mac, &peth->d_addr);
//rte_memcpy(hdr, task->src_dst_mac, sizeof(task->src_dst_mac));
}
}
@@ -340,14 +340,14 @@ static void init_task_esp_dec(struct task_base *tbase, struct task_args *targ)
}
task->local_ipv4 = rte_cpu_to_be_32(targ->local_ipv4);
- //memcpy(&task->src_mac, &prox_port_cfg[task->base.tx_params_hw.tx_port_queue->port].eth_addr, sizeof(struct ether_addr));
+ //memcpy(&task->src_mac, &prox_port_cfg[task->base.tx_params_hw.tx_port_queue->port].eth_addr, sizeof(prox_rte_ether_addr));
struct prox_port_cfg *port = find_reachable_port(targ);
- memcpy(&task->local_mac, &port->eth_addr, sizeof(struct ether_addr));
+ memcpy(&task->local_mac, &port->eth_addr, sizeof(prox_rte_ether_addr));
if (targ->flags & TASK_ARG_DST_MAC_SET){
memcpy(&task->dst_mac, &targ->edaddr, sizeof(task->dst_mac));
plog_info("TASK_ARG_DST_MAC_SET ("MAC_BYTES_FMT")\n", MAC_BYTES(task->dst_mac.addr_bytes));
- //ether_addr_copy(&ptask->dst_mac, &peth->d_addr);
+ //prox_rte_ether_addr_copy(&ptask->dst_mac, &peth->d_addr);
//rte_memcpy(hdr, task->src_dst_mac, sizeof(task->src_dst_mac));
}
@@ -356,8 +356,8 @@ static void init_task_esp_dec(struct task_base *tbase, struct task_args *targ)
static inline uint8_t handle_esp_ah_enc(struct task_esp_enc *task, struct rte_mbuf *mbuf, struct rte_crypto_op *cop)
{
u8 *data;
- 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);
uint16_t ipv4_length = rte_be_to_cpu_16(pip4->total_length);
struct rte_crypto_sym_op *sym_cop = cop->sym;
@@ -376,54 +376,54 @@ static inline uint8_t handle_esp_ah_enc(struct task_esp_enc *task, struct rte_mb
// Remove padding if any (we don't want to encapsulate garbage at end of IPv4 packet)
int l1 = rte_pktmbuf_pkt_len(mbuf);
- int padding = l1 - (ipv4_length + sizeof(struct ether_hdr));
+ int padding = l1 - (ipv4_length + sizeof(prox_rte_ether_hdr));
if (unlikely(padding > 0)) {
rte_pktmbuf_trim(mbuf, padding);
}
l1 = rte_pktmbuf_pkt_len(mbuf);
- int encrypt_len = l1 - sizeof(struct ether_hdr) + 2; // According to RFC4303 table 1, encrypt len is ip+tfc_pad(o)+pad+pad len(1) + next header(1)
+ int encrypt_len = l1 - sizeof(prox_rte_ether_hdr) + 2; // According to RFC4303 table 1, encrypt len is ip+tfc_pad(o)+pad+pad len(1) + next header(1)
padding = 0;
if ((encrypt_len & 0xf) != 0){
padding = 16 - (encrypt_len % 16);
encrypt_len += padding;
}
- const int extra_space = sizeof(struct ipv4_hdr) + sizeof(struct prox_esp_hdr) + CIPHER_IV_LENGTH_AES_CBC;
+ const int extra_space = sizeof(prox_rte_ipv4_hdr) + sizeof(struct prox_esp_hdr) + CIPHER_IV_LENGTH_AES_CBC;
- struct ether_addr src_mac = peth->s_addr;
- struct ether_addr dst_mac = peth->d_addr;
+ prox_rte_ether_addr src_mac = peth->s_addr;
+ prox_rte_ether_addr dst_mac = peth->d_addr;
uint32_t src_addr = pip4->src_addr;
uint32_t dst_addr = pip4->dst_addr;
uint8_t ttl = pip4->time_to_live;
uint8_t version_ihl = pip4->version_ihl;
- peth = (struct ether_hdr *)rte_pktmbuf_prepend(mbuf, extra_space); // encap + prefix
- peth = (struct ether_hdr *)rte_pktmbuf_append(mbuf, 0 + 1 + 1 + padding + 4 + DIGEST_BYTE_LENGTH_SHA1); // padding + pad_len + next_head + seqn + ICV pad + ICV
- peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ peth = (prox_rte_ether_hdr *)rte_pktmbuf_prepend(mbuf, extra_space); // encap + prefix
+ peth = (prox_rte_ether_hdr *)rte_pktmbuf_append(mbuf, 0 + 1 + 1 + padding + 4 + DIGEST_BYTE_LENGTH_SHA1); // padding + pad_len + next_head + seqn + ICV pad + ICV
+ peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
l1 = rte_pktmbuf_pkt_len(mbuf);
peth->ether_type = ETYPE_IPv4;
#if 0
//send it back
- ether_addr_copy(&dst_mac, &peth->s_addr);
- ether_addr_copy(&src_mac, &peth->d_addr);
+ prox_rte_ether_addr_copy(&dst_mac, &peth->s_addr);
+ prox_rte_ether_addr_copy(&src_mac, &peth->d_addr);
#else
- ether_addr_copy(&task->local_mac, &peth->s_addr);
- //ether_addr_copy(&dst_mac, &peth->d_addr);//IS: dstmac should be rewritten by arp
- ether_addr_copy(&task->dst_mac, &peth->d_addr);
+ prox_rte_ether_addr_copy(&task->local_mac, &peth->s_addr);
+ //prox_rte_ether_addr_copy(&dst_mac, &peth->d_addr);//IS: dstmac should be rewritten by arp
+ prox_rte_ether_addr_copy(&task->dst_mac, &peth->d_addr);
#endif
- pip4 = (struct ipv4_hdr *)(peth + 1);
+ pip4 = (prox_rte_ipv4_hdr *)(peth + 1);
pip4->src_addr = task->local_ipv4;
pip4->dst_addr = task->remote_ipv4;
pip4->time_to_live = ttl;
pip4->next_proto_id = IPPROTO_ESP; // 50 for ESP, ip in ip next proto trailer
pip4->version_ihl = version_ihl; // 20 bytes, ipv4
- pip4->total_length = rte_cpu_to_be_16(ipv4_length + sizeof(struct ipv4_hdr) + sizeof(struct prox_esp_hdr) + CIPHER_IV_LENGTH_AES_CBC + padding + 1 + 1 + DIGEST_BYTE_LENGTH_SHA1); // iphdr+SPI+SN+IV+payload+padding+padlen+next header + crc + auth
+ pip4->total_length = rte_cpu_to_be_16(ipv4_length + sizeof(prox_rte_ipv4_hdr) + sizeof(struct prox_esp_hdr) + CIPHER_IV_LENGTH_AES_CBC + padding + 1 + 1 + DIGEST_BYTE_LENGTH_SHA1); // iphdr+SPI+SN+IV+payload+padding+padlen+next header + crc + auth
pip4->packet_id = 0x0101;
pip4->type_of_service = 0;
pip4->time_to_live = 64;
- prox_ip_cksum(mbuf, pip4, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), 1);
+ prox_ip_cksum(mbuf, pip4, sizeof(prox_rte_ether_hdr), sizeof(prox_rte_ipv4_hdr), 1);
data = (u8*)(pip4 + 1);
#if 0
@@ -443,12 +443,12 @@ static inline uint8_t handle_esp_ah_enc(struct task_esp_enc *task, struct rte_mb
*(padl + 1) = 4; // ipv4 in 4
sym_cop->auth.digest.data = data + 8 + CIPHER_IV_LENGTH_AES_CBC + encrypt_len;
- //sym_cop->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(mbuf, (sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + 8 + CIPHER_IV_LENGTH_AES_CBC + encrypt_len));
- sym_cop->auth.digest.phys_addr = rte_pktmbuf_iova_offset(mbuf, (sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + 8 + CIPHER_IV_LENGTH_AES_CBC + encrypt_len));
+ //sym_cop->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(mbuf, (sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr) + 8 + CIPHER_IV_LENGTH_AES_CBC + encrypt_len));
+ sym_cop->auth.digest.phys_addr = rte_pktmbuf_iova_offset(mbuf, (sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr) + 8 + CIPHER_IV_LENGTH_AES_CBC + encrypt_len));
//sym_cop->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
//sym_cop->cipher.iv.data = data + 8;
- //sym_cop->cipher.iv.phys_addr = rte_pktmbuf_mtophys(mbuf) + sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + 4 + 4;
+ //sym_cop->cipher.iv.phys_addr = rte_pktmbuf_mtophys(mbuf) + sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr) + 4 + 4;
//sym_cop->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
//rte_memcpy(sym_cop->cipher.iv.data, aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
@@ -457,7 +457,7 @@ static inline uint8_t handle_esp_ah_enc(struct task_esp_enc *task, struct rte_mb
rte_memcpy(iv_ptr, aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
#if 0//old
- sym_cop->cipher.data.offset = sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + 4 + 4 + CIPHER_IV_LENGTH_AES_CBC;
+ sym_cop->cipher.data.offset = sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr) + 4 + 4 + CIPHER_IV_LENGTH_AES_CBC;
sym_cop->cipher.data.length = encrypt_len;
uint64_t *iv = (uint64_t *)(pesp + 1);
@@ -465,11 +465,11 @@ static inline uint8_t handle_esp_ah_enc(struct task_esp_enc *task, struct rte_mb
#else
//uint64_t *iv = (uint64_t *)(pesp + 1);
//memset(iv, 0, CIPHER_IV_LENGTH_AES_CBC);
- sym_cop->cipher.data.offset = sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + sizeof(struct prox_esp_hdr);
+ sym_cop->cipher.data.offset = sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr) + sizeof(struct prox_esp_hdr);
sym_cop->cipher.data.length = encrypt_len + CIPHER_IV_LENGTH_AES_CBC;
#endif
- sym_cop->auth.data.offset = sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr);
+ sym_cop->auth.data.offset = sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr);
sym_cop->auth.data.length = sizeof(struct prox_esp_hdr) + CIPHER_IV_LENGTH_AES_CBC + encrypt_len;// + 4;// FIXME
sym_cop->m_src = mbuf;
@@ -483,8 +483,8 @@ static inline uint8_t handle_esp_ah_enc(struct task_esp_enc *task, struct rte_mb
static inline uint8_t handle_esp_ah_dec(struct task_esp_dec *task, struct rte_mbuf *mbuf, struct rte_crypto_op *cop)
{
struct rte_crypto_sym_op *sym_cop = cop->sym;
- 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);
uint16_t ipv4_length = rte_be_to_cpu_16(pip4->total_length);
u8 *data = (u8*)(pip4 + 1);
@@ -497,12 +497,12 @@ static inline uint8_t handle_esp_ah_dec(struct task_esp_dec *task, struct rte_mb
rte_crypto_op_attach_sym_session(cop, task->sess);
sym_cop->auth.digest.data = (unsigned char *)((unsigned char*)pip4 + ipv4_length - DIGEST_BYTE_LENGTH_SHA1);
- //sym_cop->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(mbuf, sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + sizeof(struct prox_esp_hdr)); // FIXME
- sym_cop->auth.digest.phys_addr = rte_pktmbuf_iova_offset(mbuf, sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + sizeof(struct prox_esp_hdr));
+ //sym_cop->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(mbuf, sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr) + sizeof(struct prox_esp_hdr)); // FIXME
+ sym_cop->auth.digest.phys_addr = rte_pktmbuf_iova_offset(mbuf, sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr) + sizeof(struct prox_esp_hdr));
//sym_cop->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
//sym_cop->cipher.iv.data = (uint8_t *)data + 8;
- //sym_cop->cipher.iv.phys_addr = rte_pktmbuf_mtophys(mbuf) + sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + 4 + 4;
+ //sym_cop->cipher.iv.phys_addr = rte_pktmbuf_mtophys(mbuf) + sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr) + 4 + 4;
//sym_cop->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
#if 0
@@ -516,11 +516,11 @@ static inline uint8_t handle_esp_ah_dec(struct task_esp_dec *task, struct rte_mb
CIPHER_IV_LENGTH_AES_CBC);
#endif
- sym_cop->auth.data.offset = sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr);
- sym_cop->auth.data.length = ipv4_length - sizeof(struct ipv4_hdr) - 4 - CIPHER_IV_LENGTH_AES_CBC;
+ sym_cop->auth.data.offset = sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr);
+ sym_cop->auth.data.length = ipv4_length - sizeof(prox_rte_ipv4_hdr) - 4 - CIPHER_IV_LENGTH_AES_CBC;
- sym_cop->cipher.data.offset = sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + sizeof(struct prox_esp_hdr) + CIPHER_IV_LENGTH_AES_CBC;
- sym_cop->cipher.data.length = ipv4_length - sizeof(struct ipv4_hdr) - CIPHER_IV_LENGTH_AES_CBC - 28; // FIXME
+ sym_cop->cipher.data.offset = sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr) + sizeof(struct prox_esp_hdr) + CIPHER_IV_LENGTH_AES_CBC;
+ sym_cop->cipher.data.length = ipv4_length - sizeof(prox_rte_ipv4_hdr) - CIPHER_IV_LENGTH_AES_CBC - 28; // FIXME
sym_cop->m_src = mbuf;
return 0;
@@ -528,12 +528,12 @@ static inline uint8_t handle_esp_ah_dec(struct task_esp_dec *task, struct rte_mb
static inline void do_ipv4_swap(struct task_esp_dec *task, struct rte_mbuf *mbuf)
{
- struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
- struct ether_addr src_mac = peth->s_addr;
- struct ether_addr dst_mac = peth->d_addr;
+ prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
+ prox_rte_ether_addr src_mac = peth->s_addr;
+ prox_rte_ether_addr dst_mac = peth->d_addr;
uint32_t src_ip, dst_ip;
- struct ipv4_hdr* pip4 = (struct ipv4_hdr *)(peth + 1);
+ prox_rte_ipv4_hdr* pip4 = (prox_rte_ipv4_hdr *)(peth + 1);
src_ip = pip4->src_addr;
dst_ip = pip4->dst_addr;
@@ -541,15 +541,15 @@ static inline void do_ipv4_swap(struct task_esp_dec *task, struct rte_mbuf *mbuf
peth->d_addr = src_mac;//should be replaced by arp
pip4->src_addr = dst_ip;
pip4->dst_addr = src_ip;
- ether_addr_copy(&task->local_mac, &peth->s_addr);
+ prox_rte_ether_addr_copy(&task->local_mac, &peth->s_addr);
}
static inline uint8_t handle_esp_ah_dec_finish(struct task_esp_dec *task, struct rte_mbuf *mbuf)
{
- struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
- rte_memcpy(((u8*)peth) + sizeof(struct ether_hdr), ((u8*)peth) + sizeof(struct ether_hdr) +
- + sizeof(struct ipv4_hdr) + 4 + 4 + CIPHER_IV_LENGTH_AES_CBC, sizeof(struct ipv4_hdr));// next hdr, padding
- struct ipv4_hdr* pip4 = (struct ipv4_hdr *)(peth + 1);
+ prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
+ rte_memcpy(((u8*)peth) + sizeof(prox_rte_ether_hdr), ((u8*)peth) + sizeof(prox_rte_ether_hdr) +
+ + sizeof(prox_rte_ipv4_hdr) + 4 + 4 + CIPHER_IV_LENGTH_AES_CBC, sizeof(prox_rte_ipv4_hdr));// next hdr, padding
+ prox_rte_ipv4_hdr* pip4 = (prox_rte_ipv4_hdr *)(peth + 1);
if (unlikely((pip4->version_ihl >> 4) != 4)) {
plog_info("non IPv4 packet after esp dec %i\n", pip4->version_ihl);
@@ -564,22 +564,22 @@ static inline uint8_t handle_esp_ah_dec_finish(struct task_esp_dec *task, struct
return OUT_DISCARD;
}
uint16_t ipv4_length = rte_be_to_cpu_16(pip4->total_length);
- rte_memcpy(((u8*)peth) + sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr),
- ((u8*)peth) + sizeof(struct ether_hdr) +
- + 2 * sizeof(struct ipv4_hdr) + 4 + 4 + CIPHER_IV_LENGTH_AES_CBC, ipv4_length - sizeof(struct ipv4_hdr));
+ rte_memcpy(((u8*)peth) + sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr),
+ ((u8*)peth) + sizeof(prox_rte_ether_hdr) +
+ + 2 * sizeof(prox_rte_ipv4_hdr) + 4 + 4 + CIPHER_IV_LENGTH_AES_CBC, ipv4_length - sizeof(prox_rte_ipv4_hdr));
int len = rte_pktmbuf_pkt_len(mbuf);
- rte_pktmbuf_trim(mbuf, len - sizeof(struct ether_hdr) - ipv4_length);
- peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ rte_pktmbuf_trim(mbuf, len - sizeof(prox_rte_ether_hdr) - ipv4_length);
+ peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
#if 0
do_ipv4_swap(task, mbuf);
#else
- ether_addr_copy(&task->local_mac, &peth->s_addr);
- ether_addr_copy(&task->dst_mac, &peth->d_addr);
+ prox_rte_ether_addr_copy(&task->local_mac, &peth->s_addr);
+ prox_rte_ether_addr_copy(&task->dst_mac, &peth->d_addr);
//rte_memcpy(peth, task->dst_mac, sizeof(task->dst_mac));
#endif
- prox_ip_cksum(mbuf, pip4, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), 1);
+ prox_ip_cksum(mbuf, pip4, sizeof(prox_rte_ether_hdr), sizeof(prox_rte_ipv4_hdr), 1);
return 0;
}
@@ -587,10 +587,10 @@ static inline uint8_t handle_esp_ah_dec_finish(struct task_esp_dec *task, struct
static inline uint8_t handle_esp_ah_dec_finish2(struct task_esp_dec *task, struct rte_mbuf *mbuf)
{
u8* m = rte_pktmbuf_mtod(mbuf, u8*);
- rte_memcpy(m+sizeof(struct ipv4_hdr)+sizeof(struct prox_esp_hdr)+CIPHER_IV_LENGTH_AES_CBC,
- m, sizeof(struct ether_hdr));
- m = (u8*)rte_pktmbuf_adj(mbuf, sizeof(struct ipv4_hdr)+sizeof(struct prox_esp_hdr)+CIPHER_IV_LENGTH_AES_CBC);
- struct ipv4_hdr* pip4 = (struct ipv4_hdr *)(m+sizeof(struct ether_hdr));
+ rte_memcpy(m+sizeof(prox_rte_ipv4_hdr)+sizeof(struct prox_esp_hdr)+CIPHER_IV_LENGTH_AES_CBC,
+ m, sizeof(prox_rte_ether_hdr));
+ m = (u8*)rte_pktmbuf_adj(mbuf, sizeof(prox_rte_ipv4_hdr)+sizeof(struct prox_esp_hdr)+CIPHER_IV_LENGTH_AES_CBC);
+ prox_rte_ipv4_hdr* pip4 = (prox_rte_ipv4_hdr *)(m+sizeof(prox_rte_ether_hdr));
if (unlikely((pip4->version_ihl >> 4) != 4)) {
plog_info("non IPv4 packet after esp dec %i\n", pip4->version_ihl);
@@ -606,18 +606,18 @@ static inline uint8_t handle_esp_ah_dec_finish2(struct task_esp_dec *task, struc
}
uint16_t ipv4_length = rte_be_to_cpu_16(pip4->total_length);
int len = rte_pktmbuf_pkt_len(mbuf);
- rte_pktmbuf_trim(mbuf, len - sizeof(struct ether_hdr) - ipv4_length);
+ rte_pktmbuf_trim(mbuf, len - sizeof(prox_rte_ether_hdr) - ipv4_length);
#if 0
do_ipv4_swap(task, mbuf);
#else
- struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
- ether_addr_copy(&task->local_mac, &peth->s_addr);
- ether_addr_copy(&task->dst_mac, &peth->d_addr);
+ prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
+ prox_rte_ether_addr_copy(&task->local_mac, &peth->s_addr);
+ prox_rte_ether_addr_copy(&task->dst_mac, &peth->d_addr);
//rte_memcpy(peth, task->dst_mac, sizeof(task->dst_mac));
#endif
- prox_ip_cksum(mbuf, pip4, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), 1);
+ prox_ip_cksum(mbuf, pip4, sizeof(prox_rte_ether_hdr), sizeof(prox_rte_ipv4_hdr), 1);
return 0;
}
diff --git a/VNFs/DPPD-PROX/handle_fm.c b/VNFs/DPPD-PROX/handle_fm.c
index 75df01f0..470082b0 100644
--- a/VNFs/DPPD-PROX/handle_fm.c
+++ b/VNFs/DPPD-PROX/handle_fm.c
@@ -51,11 +51,11 @@ struct task_fm {
};
struct eth_ip4_udp {
- struct ether_hdr l2;
- struct ipv4_hdr l3;
+ prox_rte_ether_hdr l2;
+ prox_rte_ipv4_hdr l3;
union {
- struct udp_hdr udp;
- struct tcp_hdr tcp;
+ prox_rte_udp_hdr udp;
+ prox_rte_tcp_hdr tcp;
} l4;
} __attribute__((packed));
@@ -104,8 +104,8 @@ static int extract_flow_info(struct eth_ip4_udp *p, struct flow_info *fi, struct
fi_flipped->port_src = p->l4.udp.dst_port;
fi_flipped->port_dst = p->l4.udp.src_port;
- *len = rte_be_to_cpu_16(p->l4.udp.dgram_len) - sizeof(struct udp_hdr);
- *payload = (uint8_t*)(&p->l4.udp) + sizeof(struct udp_hdr);
+ *len = rte_be_to_cpu_16(p->l4.udp.dgram_len) - sizeof(prox_rte_udp_hdr);
+ *payload = (uint8_t*)(&p->l4.udp) + sizeof(prox_rte_udp_hdr);
return 0;
}
else if (pkt_type.val == pkt_type_tcp.val) {
@@ -121,7 +121,7 @@ static int extract_flow_info(struct eth_ip4_udp *p, struct flow_info *fi, struct
fi_flipped->port_src = p->l4.tcp.dst_port;
fi_flipped->port_dst = p->l4.tcp.src_port;
- *len = rte_be_to_cpu_16(p->l3.total_length) - sizeof(struct ipv4_hdr) - ((p->l4.tcp.data_off >> 4)*4);
+ *len = rte_be_to_cpu_16(p->l3.total_length) - sizeof(prox_rte_ipv4_hdr) - ((p->l4.tcp.data_off >> 4)*4);
*payload = ((uint8_t*)&p->l4.tcp) + ((p->l4.tcp.data_off >> 4)*4);
return 0;
}
@@ -132,7 +132,7 @@ static int extract_flow_info(struct eth_ip4_udp *p, struct flow_info *fi, struct
static int is_flow_beg(const struct flow_info *fi, const struct eth_ip4_udp *p)
{
return fi->ip_proto == IPPROTO_UDP ||
- (fi->ip_proto == IPPROTO_TCP && p->l4.tcp.tcp_flags & TCP_SYN_FLAG);
+ (fi->ip_proto == IPPROTO_TCP && p->l4.tcp.tcp_flags & PROX_RTE_TCP_SYN_FLAG);
}
static void *lookup_flow(struct task_fm *task, struct flow_info *fi, uint64_t now_tsc)
diff --git a/VNFs/DPPD-PROX/handle_gen.c b/VNFs/DPPD-PROX/handle_gen.c
index 4fd2c399..3bcb231f 100644
--- a/VNFs/DPPD-PROX/handle_gen.c
+++ b/VNFs/DPPD-PROX/handle_gen.c
@@ -116,18 +116,18 @@ struct task_gen {
uint64_t accur[ACCURACY_WINDOW];
uint64_t pkt_tsc_offset[64];
struct pkt_template *pkt_template_orig; /* packet templates (from inline or from pcap) */
- struct ether_addr src_mac;
+ prox_rte_ether_addr src_mac;
uint8_t flags;
uint8_t cksum_offload;
struct prox_port_cfg *port;
uint64_t *bytes_to_tsc;
} __rte_cache_aligned;
-static inline uint8_t ipv4_get_hdr_len(struct ipv4_hdr *ip)
+static inline uint8_t ipv4_get_hdr_len(prox_rte_ipv4_hdr *ip)
{
/* Optimize for common case of IPv4 header without options. */
if (ip->version_ihl == 0x45)
- return sizeof(struct ipv4_hdr);
+ return sizeof(prox_rte_ipv4_hdr);
if (unlikely(ip->version_ihl >> 4 != 4)) {
plog_warn("IPv4 ether_type but IP version = %d != 4", ip->version_ihl >> 4);
return 0;
@@ -137,16 +137,16 @@ static inline uint8_t ipv4_get_hdr_len(struct ipv4_hdr *ip)
static void parse_l2_l3_len(uint8_t *pkt, uint16_t *l2_len, uint16_t *l3_len, uint16_t len)
{
- *l2_len = sizeof(struct ether_hdr);
+ *l2_len = sizeof(prox_rte_ether_hdr);
*l3_len = 0;
- struct vlan_hdr *vlan_hdr;
- struct ether_hdr *eth_hdr = (struct ether_hdr*)pkt;
- struct ipv4_hdr *ip;
+ prox_rte_vlan_hdr *vlan_hdr;
+ prox_rte_ether_hdr *eth_hdr = (prox_rte_ether_hdr*)pkt;
+ prox_rte_ipv4_hdr *ip;
uint16_t ether_type = eth_hdr->ether_type;
// Unstack VLAN tags
- while (((ether_type == ETYPE_8021ad) || (ether_type == ETYPE_VLAN)) && (*l2_len + sizeof(struct vlan_hdr) < len)) {
- vlan_hdr = (struct vlan_hdr *)(pkt + *l2_len);
+ while (((ether_type == ETYPE_8021ad) || (ether_type == ETYPE_VLAN)) && (*l2_len + sizeof(prox_rte_vlan_hdr) < len)) {
+ vlan_hdr = (prox_rte_vlan_hdr *)(pkt + *l2_len);
*l2_len +=4;
ether_type = vlan_hdr->eth_proto;
}
@@ -173,7 +173,7 @@ static void parse_l2_l3_len(uint8_t *pkt, uint16_t *l2_len, uint16_t *l3_len, ui
}
if (*l2_len) {
- struct ipv4_hdr *ip = (struct ipv4_hdr *)(pkt + *l2_len);
+ prox_rte_ipv4_hdr *ip = (prox_rte_ipv4_hdr *)(pkt + *l2_len);
*l3_len = ipv4_get_hdr_len(ip);
}
}
@@ -184,7 +184,7 @@ static void checksum_packet(uint8_t *hdr, struct rte_mbuf *mbuf, struct pkt_temp
uint16_t l3_len = pkt_template->l3_len;
if (l2_len) {
- struct ipv4_hdr *ip = (struct ipv4_hdr*)(hdr + l2_len);
+ prox_rte_ipv4_hdr *ip = (prox_rte_ipv4_hdr*)(hdr + l2_len);
prox_ip_udp_cksum(mbuf, ip, l2_len, l3_len, cksum_offload);
}
}
@@ -528,7 +528,7 @@ static void task_gen_build_packets(struct task_gen *task, struct rte_mbuf **mbuf
struct pkt_template *pktpl = &task->pkt_template[task->pkt_idx];
struct pkt_template *pkt_template = &task->pkt_template[task->pkt_idx];
pkt_template_init_mbuf(pkt_template, mbufs[i], pkt_hdr[i]);
- struct ether_hdr *hdr = (struct ether_hdr *)pkt_hdr[i];
+ prox_rte_ether_hdr *hdr = (prox_rte_ether_hdr *)pkt_hdr[i];
if (task->lat_enabled) {
#ifdef NO_EXTRAPOLATION
task->pkt_tsc_offset[i] = 0;
@@ -570,16 +570,16 @@ static inline void register_all_ip_to_ctrl_plane(struct task_gen *task)
struct pkt_template *pktpl = &task->pkt_template[i];
unsigned int ip_src_pos = 0;
int maybe_ipv4 = 0;
- unsigned int l2_len = sizeof(struct ether_hdr);
+ unsigned int l2_len = sizeof(prox_rte_ether_hdr);
uint8_t *pkt = pktpl->buf;
- struct ether_hdr *eth_hdr = (struct ether_hdr*)pkt;
+ prox_rte_ether_hdr *eth_hdr = (prox_rte_ether_hdr*)pkt;
uint16_t ether_type = eth_hdr->ether_type;
- struct vlan_hdr *vlan_hdr;
+ prox_rte_vlan_hdr *vlan_hdr;
// Unstack VLAN tags
- while (((ether_type == ETYPE_8021ad) || (ether_type == ETYPE_VLAN)) && (l2_len + sizeof(struct vlan_hdr) < pktpl->len)) {
- vlan_hdr = (struct vlan_hdr *)(pkt + l2_len);
+ while (((ether_type == ETYPE_8021ad) || (ether_type == ETYPE_VLAN)) && (l2_len + sizeof(prox_rte_vlan_hdr) < pktpl->len)) {
+ vlan_hdr = (prox_rte_vlan_hdr *)(pkt + l2_len);
l2_len +=4;
ether_type = vlan_hdr->eth_proto;
}
@@ -590,11 +590,11 @@ static inline void register_all_ip_to_ctrl_plane(struct task_gen *task)
if ((ether_type != ETYPE_IPv4) && !maybe_ipv4)
continue;
- struct ipv4_hdr *ip = (struct ipv4_hdr *)(pkt + l2_len);
+ prox_rte_ipv4_hdr *ip = (prox_rte_ipv4_hdr *)(pkt + l2_len);
PROX_PANIC(ip->version_ihl >> 4 != 4, "IPv4 ether_type but IP version = %d != 4", ip->version_ihl >> 4);
// Even if IPv4 header contains options, options are after ip src and dst
- ip_src_pos = l2_len + sizeof(struct ipv4_hdr) - 2 * sizeof(uint32_t);
+ ip_src_pos = l2_len + sizeof(prox_rte_ipv4_hdr) - 2 * sizeof(uint32_t);
uint32_t *ip_src = ((uint32_t *)(pktpl->buf + ip_src_pos));
plog_info("\tip_src_pos = %d, ip_src = %x\n", ip_src_pos, *ip_src);
register_ip_to_ctrl_plane(tbase->l3.tmaster, *ip_src, tbase->l3.reachable_port_id, tbase->l3.core_id, tbase->l3.task_id);
@@ -761,7 +761,7 @@ static int pcap_read_pkts(pcap_t *handle, const char *file_name, uint32_t n_pkts
static int check_pkt_size(struct task_gen *task, uint32_t pkt_size, int do_panic)
{
- const uint16_t min_len = sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr);
+ const uint16_t min_len = sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr);
const uint16_t max_len = task->max_frame_size;
if (do_panic) {
@@ -850,24 +850,24 @@ static void task_gen_pkt_template_recalc_metadata(struct task_gen *task)
static void task_gen_pkt_template_recalc_checksum(struct task_gen *task)
{
struct pkt_template *template;
- struct ipv4_hdr *ip;
+ prox_rte_ipv4_hdr *ip;
task->runtime_checksum_needed = 0;
for (size_t i = 0; i < task->n_pkts; ++i) {
template = &task->pkt_template[i];
if (template->l2_len == 0)
continue;
- ip = (struct ipv4_hdr *)(template->buf + template->l2_len);
+ ip = (prox_rte_ipv4_hdr *)(template->buf + template->l2_len);
ip->hdr_checksum = 0;
prox_ip_cksum_sw(ip);
uint32_t l4_len = rte_bswap16(ip->total_length) - template->l3_len;
if (ip->next_proto_id == IPPROTO_UDP) {
- struct udp_hdr *udp = (struct udp_hdr *)(((uint8_t *)ip) + template->l3_len);
+ prox_rte_udp_hdr *udp = (prox_rte_udp_hdr *)(((uint8_t *)ip) + template->l3_len);
prox_udp_cksum_sw(udp, l4_len, ip->src_addr, ip->dst_addr);
} else if (ip->next_proto_id == IPPROTO_TCP) {
- struct tcp_hdr *tcp = (struct tcp_hdr *)(((uint8_t *)ip) + template->l3_len);
+ prox_rte_tcp_hdr *tcp = (prox_rte_tcp_hdr *)(((uint8_t *)ip) + template->l3_len);
prox_tcp_cksum_sw(tcp, l4_len, ip->src_addr, ip->dst_addr);
}
@@ -941,7 +941,7 @@ static void task_init_gen_load_pkt_inline(struct task_gen *task, struct task_arg
"Failed to allocate %u bytes (in huge pages) for packet\n", task->max_frame_size);
PROX_PANIC(targ->pkt_size > task->max_frame_size,
- targ->pkt_size > ETHER_MAX_LEN + 2 * PROX_VLAN_TAG_SIZE - 4 ?
+ targ->pkt_size > PROX_RTE_ETHER_MAX_LEN + 2 * PROX_VLAN_TAG_SIZE - 4 ?
"pkt_size too high and jumbo frames disabled" : "pkt_size > mtu");
rte_memcpy(task->pkt_template_orig[0].buf, targ->pkt_inline, targ->pkt_size);
@@ -962,7 +962,7 @@ static void task_init_gen_load_pcap(struct task_gen *task, struct task_args *tar
task->n_pkts = pcap_count_pkts(handle, &max_frame_size);
plogx_info("%u packets in pcap file '%s'; max frame size=%d\n", task->n_pkts, targ->pcap_file, max_frame_size);
PROX_PANIC(max_frame_size > task->max_frame_size,
- max_frame_size > ETHER_MAX_LEN + 2 * PROX_VLAN_TAG_SIZE -4 ?
+ max_frame_size > PROX_RTE_ETHER_MAX_LEN + 2 * PROX_VLAN_TAG_SIZE -4 ?
"pkt_size too high and jumbo frames disabled" : "pkt_size > mtu");
if (targ->n_pkts)
@@ -1081,7 +1081,7 @@ void task_gen_reset_values(struct task_base *tbase)
task_gen_reset_pkt_templates_content(task);
if (task->flags & TASK_OVERWRITE_SRC_MAC_WITH_PORT_MAC) {
for (uint32_t i = 0; i < task->n_pkts; ++i) {
- rte_memcpy(&task->pkt_template[i].buf[sizeof(struct ether_addr)], &task->src_mac, sizeof(struct ether_addr));
+ rte_memcpy(&task->pkt_template[i].buf[sizeof(prox_rte_ether_addr)], &task->src_mac, sizeof(prox_rte_ether_addr));
}
}
}
@@ -1237,10 +1237,10 @@ static void init_task_gen(struct task_base *tbase, struct task_args *targ)
if (port) {
task->cksum_offload = port->requested_tx_offload & (DEV_TX_OFFLOAD_IPV4_CKSUM | DEV_TX_OFFLOAD_UDP_CKSUM);
task->port = port;
- task->max_frame_size = port->mtu + ETHER_HDR_LEN + 2 * PROX_VLAN_TAG_SIZE;
+ task->max_frame_size = port->mtu + PROX_RTE_ETHER_HDR_LEN + 2 * PROX_VLAN_TAG_SIZE;
} else {
// Not generating to any port...
- task->max_frame_size = ETHER_MAX_LEN;
+ task->max_frame_size = PROX_RTE_ETHER_MAX_LEN;
}
task->local_mbuf.mempool = task_gen_create_mempool(targ, task->max_frame_size);
PROX_PANIC(task->local_mbuf.mempool == NULL, "Failed to create mempool\n");
@@ -1315,9 +1315,9 @@ static void init_task_gen(struct task_base *tbase, struct task_args *targ)
PROX_PANIC(((targ->nb_txrings == 0) && (targ->nb_txports == 0)), "Gen mode requires a tx ring or a tx port");
if ((targ->flags & DSF_KEEP_SRC_MAC) == 0) {
task->flags |= TASK_OVERWRITE_SRC_MAC_WITH_PORT_MAC;
- memcpy(&task->src_mac, &prox_port_cfg[task->base.tx_params_hw.tx_port_queue->port].eth_addr, sizeof(struct ether_addr));
+ memcpy(&task->src_mac, &prox_port_cfg[task->base.tx_params_hw.tx_port_queue->port].eth_addr, sizeof(prox_rte_ether_addr));
for (uint32_t i = 0; i < task->n_pkts; ++i) {
- rte_memcpy(&task->pkt_template[i].buf[sizeof(struct ether_addr)], &task->src_mac, sizeof(struct ether_addr));
+ rte_memcpy(&task->pkt_template[i].buf[sizeof(prox_rte_ether_addr)], &task->src_mac, sizeof(prox_rte_ether_addr));
}
}
for (uint32_t i = 0; i < targ->n_rand_str; ++i) {
diff --git a/VNFs/DPPD-PROX/handle_genl4.c b/VNFs/DPPD-PROX/handle_genl4.c
index 056bd838..49fde3fc 100644
--- a/VNFs/DPPD-PROX/handle_genl4.c
+++ b/VNFs/DPPD-PROX/handle_genl4.c
@@ -439,9 +439,9 @@ static int handle_gen_scheduled(struct task_gen_server *task)
}
else {
- struct ether_hdr *eth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
- struct ipv4_hdr *ip = (struct ipv4_hdr*)(eth + 1);
- struct tcp_hdr *tcp = (struct tcp_hdr*)(ip + 1);
+ prox_rte_ether_hdr *eth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
+ prox_rte_ipv4_hdr *ip = (prox_rte_ipv4_hdr*)(eth + 1);
+ prox_rte_tcp_hdr *tcp = (prox_rte_tcp_hdr*)(ip + 1);
task->out_saved = 0;
task->cancelled = 1;
@@ -732,8 +732,8 @@ static int lua_to_stream_cfg(struct lua_State *L, enum lua_place from, const cha
const uint64_t hz = rte_get_tsc_hz();
- ret->tt_cfg[PEER_CLIENT] = token_time_cfg_create(up, hz, ETHER_MAX_LEN + 20);
- ret->tt_cfg[PEER_SERVER] = token_time_cfg_create(dn, hz, ETHER_MAX_LEN + 20);
+ ret->tt_cfg[PEER_CLIENT] = token_time_cfg_create(up, hz, PROX_RTE_ETHER_MAX_LEN + 20);
+ ret->tt_cfg[PEER_SERVER] = token_time_cfg_create(dn, hz, PROX_RTE_ETHER_MAX_LEN + 20);
if (!strcmp(proto, "tcp")) {
ret->proto = IPPROTO_TCP;
@@ -946,7 +946,7 @@ static void init_task_gen(struct task_base *tbase, struct task_args *targ)
struct token_time_cfg tt_cfg = {
.bpp = targ->rate_bps,
.period = rte_get_tsc_hz(),
- .bytes_max = n_descriptors * (ETHER_MIN_LEN + 20),
+ .bytes_max = n_descriptors * (PROX_RTE_ETHER_MIN_LEN + 20),
};
token_time_init(&task->token_time, &tt_cfg);
@@ -1025,7 +1025,7 @@ static void init_task_gen_client(struct task_base *tbase, struct task_args *targ
task->heap = heap_create(targ->n_concur_conn, socket);
task->seed = rte_rdtsc();
- /* task->token_time.bytes_max = MAX_PKT_BURST * (ETHER_MAX_LEN + 20); */
+ /* task->token_time.bytes_max = MAX_PKT_BURST * (PROX_RTE_ETHER_MAX_LEN + 20); */
/* To avoid overflowing the tx descriptors, the token bucket
size needs to be limited. The descriptors are filled most
@@ -1037,7 +1037,7 @@ static void init_task_gen_client(struct task_base *tbase, struct task_args *targ
struct token_time_cfg tt_cfg = {
.bpp = targ->rate_bps,
.period = rte_get_tsc_hz(),
- .bytes_max = prox_port_cfg[targ->tx_port_queue[0].port].n_txd * (ETHER_MIN_LEN + 20),
+ .bytes_max = prox_port_cfg[targ->tx_port_queue[0].port].n_txd * (PROX_RTE_ETHER_MIN_LEN + 20),
};
token_time_init(&task->token_time, &tt_cfg);
diff --git a/VNFs/DPPD-PROX/handle_gre_decap_encap.c b/VNFs/DPPD-PROX/handle_gre_decap_encap.c
index 02ba4c36..83e430a6 100644
--- a/VNFs/DPPD-PROX/handle_gre_decap_encap.c
+++ b/VNFs/DPPD-PROX/handle_gre_decap_encap.c
@@ -37,7 +37,7 @@
#include "quit.h"
struct cpe_gre_key {
- struct ether_addr clt_mac;
+ prox_rte_ether_addr clt_mac;
uint16_t pad;
} __attribute__((__packed__));
@@ -219,12 +219,12 @@ void handle_gre_decap_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uin
}
struct gre_packet {
- struct ether_hdr eth;
- struct ipv4_hdr ip;
+ prox_rte_ether_hdr eth;
+ prox_rte_ipv4_hdr ip;
struct gre_hdr gre;
union {
- struct ether_hdr eth2;
- struct ipv4_hdr ip2;
+ prox_rte_ether_hdr eth2;
+ prox_rte_ipv4_hdr ip2;
};
} __attribute__((__packed__));
@@ -232,26 +232,26 @@ struct gre_packet {
GRE remove gre and ipv4 header and retain space for ethernet
header. In case of Eth over GRE remove external eth, gre and ipv4
headers and return pointer to payload */
-static inline struct ether_hdr *gre_decap(struct gre_hdr *pgre, struct rte_mbuf *mbuf)
+static inline prox_rte_ether_hdr *gre_decap(struct gre_hdr *pgre, struct rte_mbuf *mbuf)
{
int16_t hsize = 0;
if (pgre->type == ETYPE_EoGRE) {
- hsize = sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + sizeof(struct gre_hdr);
+ hsize = sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr) + sizeof(struct gre_hdr);
}
else if (pgre->type == ETYPE_IPv4) {
- /* retain sizeof(struct ether_hdr) */
- hsize = sizeof(struct ipv4_hdr) + sizeof(struct gre_hdr);
+ /* retain sizeof(prox_rte_ether_hdr) */
+ hsize = sizeof(prox_rte_ipv4_hdr) + sizeof(struct gre_hdr);
}
else {
return NULL;
}
- return (struct ether_hdr *)rte_pktmbuf_adj(mbuf, hsize);
+ return (prox_rte_ether_hdr *)rte_pktmbuf_adj(mbuf, hsize);
}
static inline uint8_t handle_gre_decap(struct task_gre_decap *task, struct rte_mbuf *mbuf)
{
- struct ipv4_hdr *pip = (struct ipv4_hdr *)(rte_pktmbuf_mtod(mbuf, struct ether_hdr *) + 1);
+ prox_rte_ipv4_hdr *pip = (prox_rte_ipv4_hdr *)(rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *) + 1);
if (pip->next_proto_id != IPPROTO_GRE) {
plog_warn("Invalid packet proto_id = 0x%x expect 0x%x\n",
@@ -265,15 +265,15 @@ static inline uint8_t handle_gre_decap(struct task_gre_decap *task, struct rte_m
data.gre_id = pgre->gre_id;
data.cpe_ip = pip->src_addr;
- struct ether_hdr *peth = gre_decap(pgre, mbuf);
+ prox_rte_ether_hdr *peth = gre_decap(pgre, mbuf);
PROX_PANIC(peth != 0, "Failed to gre_decap");
- pip = (struct ipv4_hdr *)(peth + 1);
+ pip = (prox_rte_ipv4_hdr *)(peth + 1);
/* emulate client MAC for test purposes */
#if 1
if (pgre->type == ETYPE_IPv4) {
- struct ether_hdr eth = {
+ prox_rte_ether_hdr eth = {
.d_addr = {.addr_bytes =
{0x0A, 0x02, 0x0A, 0x0A, 0x00, 0x01}},
.s_addr = {.addr_bytes =
@@ -285,9 +285,9 @@ static inline uint8_t handle_gre_decap(struct task_gre_decap *task, struct rte_m
eth.s_addr.addr_bytes[3] = (hip >> 16) & 0xFF;
eth.s_addr.addr_bytes[4] = (hip >> 8) & 0xFF;
eth.s_addr.addr_bytes[5] = (hip) & 0xFF;
- rte_memcpy(peth, &eth, sizeof(struct ether_hdr));
+ rte_memcpy(peth, &eth, sizeof(prox_rte_ether_hdr));
}
- ether_addr_copy(&peth->s_addr, &key.clt_mac);
+ prox_rte_ether_addr_copy(&peth->s_addr, &key.clt_mac);
#endif
data.tsc = rte_rdtsc() + task->cpe_timeout;
@@ -303,7 +303,7 @@ static inline uint8_t handle_gre_decap(struct task_gre_decap *task, struct rte_m
}
rte_memcpy(&task->cpe_gre_data[hash_index], &data, sizeof(data));
if (task->runtime_flags & TASK_TX_CRC) {
- prox_ip_cksum(mbuf, pip, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+ prox_ip_cksum(mbuf, pip, sizeof(prox_rte_ether_hdr), sizeof(prox_rte_ipv4_hdr), task->offload_crc);
}
return 0;
@@ -333,8 +333,8 @@ void handle_gre_encap_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uin
static inline void handle_gre_encap16(struct task_gre_decap *task, struct rte_mbuf **mbufs, uint16_t n_pkts, uint8_t *out)
{
for (uint8_t i = 0; i < n_pkts; ++i) {
- struct ether_hdr *peth = rte_pktmbuf_mtod(mbufs[i], struct ether_hdr *);
- ether_addr_copy(&peth->d_addr, &task->key[i].clt_mac);
+ prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbufs[i], prox_rte_ether_hdr *);
+ prox_rte_ether_addr_copy(&peth->d_addr, &task->key[i].clt_mac);
}
int32_t hash_index[16];
@@ -359,24 +359,24 @@ static inline void handle_gre_encap16(struct task_gre_decap *task, struct rte_mb
}
#ifdef DO_ENC_ETH_OVER_GRE
-#define PKT_PREPEND_LEN (sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + sizeof(struct gre_hdr))
+#define PKT_PREPEND_LEN (sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr) + sizeof(struct gre_hdr))
#elif DO_ENC_IP_OVER_GRE
-#define PKT_PREPEND_LEN (sizeof(struct ipv4_hdr) + sizeof(struct gre_hdr))
+#define PKT_PREPEND_LEN (sizeof(prox_rte_ipv4_hdr) + sizeof(struct gre_hdr))
#else
static inline uint8_t handle_gre_encap(struct task_gre_decap *task, struct rte_mbuf *mbuf, struct cpe_gre_data *table)
{
- struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
- struct ipv4_hdr *pip = (struct ipv4_hdr *)(peth + 1);
+ prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
+ prox_rte_ipv4_hdr *pip = (prox_rte_ipv4_hdr *)(peth + 1);
uint16_t ip_len = rte_be_to_cpu_16(pip->total_length);
struct cpe_gre_key key;
- ether_addr_copy(&peth->d_addr, &key.clt_mac);
+ prox_rte_ether_addr_copy(&peth->d_addr, &key.clt_mac);
#ifdef GRE_TP
/* policing enabled */
if (task->cycles_per_byte) {
- const uint16_t pkt_size = rte_pktmbuf_pkt_len(mbuf) + ETHER_CRC_LEN;
+ const uint16_t pkt_size = rte_pktmbuf_pkt_len(mbuf) + PROX_RTE_ETHER_CRC_LEN;
uint64_t tsc_now = rte_rdtsc();
if (table->tp_tbsize < pkt_size) {
uint64_t cycles_diff = tsc_now - table->tp_tsc;
@@ -399,19 +399,19 @@ static inline uint8_t handle_gre_encap(struct task_gre_decap *task, struct rte_m
/* reuse ethernet header from payload, retain payload (ip) in
case of DO_ENC_IP_OVER_GRE */
- peth = (struct ether_hdr *)rte_pktmbuf_prepend(mbuf, PKT_PREPEND_LEN);
+ peth = (prox_rte_ether_hdr *)rte_pktmbuf_prepend(mbuf, PKT_PREPEND_LEN);
PREFETCH0(peth);
ip_len += PKT_PREPEND_LEN;
- pip = (struct ipv4_hdr *)(peth + 1);
+ pip = (prox_rte_ipv4_hdr *)(peth + 1);
struct gre_hdr *pgre = (struct gre_hdr *)(pip + 1);
- struct ether_hdr eth = {
+ prox_rte_ether_hdr eth = {
.d_addr = {.addr_bytes = {0x0A, 0x0A, 0x0A, 0xC8, 0x00, 0x02}},
.s_addr = {.addr_bytes = {0x0A, 0x0A, 0x0A, 0xC8, 0x00, 0x01}},
.ether_type = ETYPE_IPv4
};
- rte_memcpy(peth, &eth, sizeof(struct ether_hdr));
+ rte_memcpy(peth, &eth, sizeof(prox_rte_ether_hdr));
rte_memcpy(pgre, &gre_hdr_proto, sizeof(struct gre_hdr));
#if DO_ENC_ETH_OVER_GRE
@@ -421,13 +421,13 @@ static inline uint8_t handle_gre_encap(struct task_gre_decap *task, struct rte_m
#endif
pgre->gre_id = table->gre_id;
- rte_memcpy(pip, &tunnel_ip_proto, sizeof(struct ipv4_hdr));
+ rte_memcpy(pip, &tunnel_ip_proto, sizeof(prox_rte_ipv4_hdr));
pip->src_addr = 0x02010a0a; //emulate port ip
pip->dst_addr = table->cpe_ip;
pip->total_length = rte_cpu_to_be_16(ip_len);
if (task->runtime_flags & TASK_TX_CRC) {
- prox_ip_cksum(mbuf, pip, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+ prox_ip_cksum(mbuf, pip, sizeof(prox_rte_ether_hdr), sizeof(prox_rte_ipv4_hdr), task->offload_crc);
}
return 0;
diff --git a/VNFs/DPPD-PROX/handle_impair.c b/VNFs/DPPD-PROX/handle_impair.c
index 805dedfc..3896b70f 100644
--- a/VNFs/DPPD-PROX/handle_impair.c
+++ b/VNFs/DPPD-PROX/handle_impair.c
@@ -192,18 +192,18 @@ static int handle_bulk_random_drop(struct task_base *tbase, struct rte_mbuf **mb
{
struct task_impair *task = (struct task_impair *)tbase;
uint8_t out[MAX_PKT_BURST];
- struct ether_hdr * hdr[MAX_PKT_BURST];
+ prox_rte_ether_hdr * hdr[MAX_PKT_BURST];
int ret = 0;
for (uint16_t i = 0; i < n_pkts; ++i) {
PREFETCH0(mbufs[i]);
}
for (uint16_t i = 0; i < n_pkts; ++i) {
- hdr[i] = rte_pktmbuf_mtod(mbufs[i], struct ether_hdr *);
+ hdr[i] = rte_pktmbuf_mtod(mbufs[i], prox_rte_ether_hdr *);
PREFETCH0(hdr[i]);
}
if (task->flags & IMPAIR_SET_MAC) {
for (uint16_t i = 0; i < n_pkts; ++i) {
- ether_addr_copy((struct ether_addr *)&task->src_mac[0], &hdr[i]->s_addr);
+ prox_rte_ether_addr_copy((prox_rte_ether_addr *)&task->src_mac[0], &hdr[i]->s_addr);
out[i] = rand_r(&task->seed) <= task->tresh? 0 : OUT_DISCARD;
}
} else {
@@ -224,12 +224,12 @@ static int handle_bulk_impair(struct task_base *tbase, struct rte_mbuf **mbufs,
uint16_t enqueue_failed;
uint16_t i;
int ret = 0;
- struct ether_hdr * hdr[MAX_PKT_BURST];
+ prox_rte_ether_hdr * hdr[MAX_PKT_BURST];
for (uint16_t i = 0; i < n_pkts; ++i) {
PREFETCH0(mbufs[i]);
}
for (uint16_t i = 0; i < n_pkts; ++i) {
- hdr[i] = rte_pktmbuf_mtod(mbufs[i], struct ether_hdr *);
+ hdr[i] = rte_pktmbuf_mtod(mbufs[i], prox_rte_ether_hdr *);
PREFETCH0(hdr[i]);
}
@@ -238,7 +238,7 @@ static int handle_bulk_impair(struct task_base *tbase, struct rte_mbuf **mbufs,
/* We know n_pkts fits, no need to check for every packet */
for (i = 0; i < n_pkts; ++i) {
if (task->flags & IMPAIR_SET_MAC)
- ether_addr_copy((struct ether_addr *)&task->src_mac[0], &hdr[i]->s_addr);
+ prox_rte_ether_addr_copy((prox_rte_ether_addr *)&task->src_mac[0], &hdr[i]->s_addr);
task->queue[task->queue_head].tsc = now + task->delay_time;
task->queue[task->queue_head].mbuf = mbufs[i];
task->queue_head = (task->queue_head + 1) & task->queue_mask;
@@ -247,7 +247,7 @@ static int handle_bulk_impair(struct task_base *tbase, struct rte_mbuf **mbufs,
for (i = 0; i < n_pkts; ++i) {
if (((task->queue_head + 1) & task->queue_mask) != task->queue_tail) {
if (task->flags & IMPAIR_SET_MAC)
- ether_addr_copy((struct ether_addr *)&task->src_mac[0], &hdr[i]->s_addr);
+ prox_rte_ether_addr_copy((prox_rte_ether_addr *)&task->src_mac[0], &hdr[i]->s_addr);
task->queue[task->queue_head].tsc = now + task->delay_time;
task->queue[task->queue_head].mbuf = mbufs[i];
task->queue_head = (task->queue_head + 1) & task->queue_mask;
@@ -336,12 +336,12 @@ static int handle_bulk_impair_random(struct task_base *tbase, struct rte_mbuf **
int ret = 0;
uint64_t packet_time, idx;
uint64_t now_idx = (now >> DELAY_ACCURACY) & DELAY_MAX_MASK;
- struct ether_hdr * hdr[MAX_PKT_BURST];
+ prox_rte_ether_hdr * hdr[MAX_PKT_BURST];
for (uint16_t i = 0; i < n_pkts; ++i) {
PREFETCH0(mbufs[i]);
}
for (uint16_t i = 0; i < n_pkts; ++i) {
- hdr[i] = rte_pktmbuf_mtod(mbufs[i], struct ether_hdr *);
+ hdr[i] = rte_pktmbuf_mtod(mbufs[i], prox_rte_ether_hdr *);
PREFETCH0(hdr[i]);
}
@@ -352,7 +352,7 @@ static int handle_bulk_impair_random(struct task_base *tbase, struct rte_mbuf **
struct queue *queue = &task->buffer[idx];
if (((queue->queue_head + 1) & task->queue_mask) != queue->queue_tail) {
if (task->flags & IMPAIR_SET_MAC)
- ether_addr_copy((struct ether_addr *)&task->src_mac[0], &hdr[i]->s_addr);
+ prox_rte_ether_addr_copy((prox_rte_ether_addr *)&task->src_mac[0], &hdr[i]->s_addr);
queue->queue_elem[queue->queue_head].mbuf = mbufs[i];
queue->queue_head = (queue->queue_head + 1) & task->queue_mask;
break;
@@ -450,7 +450,7 @@ static void init_task(struct task_base *tbase, struct task_args *targ)
}
random_init_seed(&task->state);
if (targ->nb_txports) {
- memcpy(&task->src_mac[0], &prox_port_cfg[tbase->tx_params_hw.tx_port_queue[0].port].eth_addr, sizeof(struct ether_addr));
+ memcpy(&task->src_mac[0], &prox_port_cfg[tbase->tx_params_hw.tx_port_queue[0].port].eth_addr, sizeof(prox_rte_ether_addr));
task->flags = IMPAIR_SET_MAC;
} else {
task->flags = 0;
diff --git a/VNFs/DPPD-PROX/handle_ipv6_tunnel.c b/VNFs/DPPD-PROX/handle_ipv6_tunnel.c
index cf56069e..a99a8f96 100644
--- a/VNFs/DPPD-PROX/handle_ipv6_tunnel.c
+++ b/VNFs/DPPD-PROX/handle_ipv6_tunnel.c
@@ -49,7 +49,7 @@
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 {
@@ -59,7 +59,7 @@ 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];
@@ -71,7 +71,7 @@ struct task_ipv6_tun_base {
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 {
@@ -131,7 +131,7 @@ static void init_lookup_table(struct task_ipv6_tun_base* ptask, struct task_args
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 = 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);
@@ -221,16 +221,16 @@ __attribute__((constructor)) static void reg_task_ipv6_encap(void)
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 {
@@ -242,7 +242,7 @@ static inline int extract_key_fields( __attribute__((unused)) struct task_ipv6_t
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;
@@ -256,19 +256,19 @@ static inline void extract_key(struct task_ipv6_tun_base* ptask, struct ipv4_hdr
*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;
}
@@ -303,7 +303,7 @@ __attribute__((cold)) static void handle_error(struct task_ipv6_tun_base* ptask,
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);
@@ -381,9 +381,9 @@ static int handle_ipv6_encap_bulk(struct task_base* tbase, struct rte_mbuf** mbu
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");
@@ -391,8 +391,8 @@ static inline uint8_t handle_ipv6_decap(struct task_ipv6_decap* ptask, struct rt
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
@@ -406,18 +406,18 @@ static inline uint8_t handle_ipv6_decap(struct task_ipv6_decap* ptask, struct rt
// 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
@@ -428,8 +428,8 @@ static inline uint8_t handle_ipv6_encap(struct task_ipv6_encap* ptask, struct rt
{
//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;
@@ -449,22 +449,22 @@ static inline uint8_t handle_ipv6_encap(struct task_ipv6_encap* ptask, struct rt
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);
@@ -474,8 +474,8 @@ static inline uint8_t handle_ipv6_encap(struct task_ipv6_encap* ptask, struct rt
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;
}
diff --git a/VNFs/DPPD-PROX/handle_l2fwd.c b/VNFs/DPPD-PROX/handle_l2fwd.c
index e5a8c338..35d331b6 100644
--- a/VNFs/DPPD-PROX/handle_l2fwd.c
+++ b/VNFs/DPPD-PROX/handle_l2fwd.c
@@ -31,32 +31,32 @@ struct task_l2fwd {
static int handle_l2fwd_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
{
struct task_l2fwd *task = (struct task_l2fwd *)tbase;
- struct ether_hdr *hdr;
- struct ether_addr mac;
+ prox_rte_ether_hdr *hdr;
+ prox_rte_ether_addr mac;
if ((task->runtime_flags & (TASK_ARG_DST_MAC_SET|TASK_ARG_SRC_MAC_SET)) == (TASK_ARG_DST_MAC_SET|TASK_ARG_SRC_MAC_SET)) {
/* Source and Destination mac hardcoded */
for (uint16_t j = 0; j < n_pkts; ++j) {
- hdr = rte_pktmbuf_mtod(mbufs[j], struct ether_hdr *);
+ hdr = rte_pktmbuf_mtod(mbufs[j], prox_rte_ether_hdr *);
rte_memcpy(hdr, task->src_dst_mac, sizeof(task->src_dst_mac));
}
} else {
for (uint16_t j = 0; j < n_pkts; ++j) {
- hdr = rte_pktmbuf_mtod(mbufs[j], struct ether_hdr *);
+ hdr = rte_pktmbuf_mtod(mbufs[j], prox_rte_ether_hdr *);
if ((task->runtime_flags & (TASK_ARG_DO_NOT_SET_SRC_MAC|TASK_ARG_SRC_MAC_SET)) == 0) {
/* dst mac will be used as src mac */
- ether_addr_copy(&hdr->d_addr, &mac);
+ prox_rte_ether_addr_copy(&hdr->d_addr, &mac);
}
if (task->runtime_flags & TASK_ARG_DST_MAC_SET)
- ether_addr_copy((struct ether_addr *)&task->src_dst_mac[0], &hdr->d_addr);
+ prox_rte_ether_addr_copy((prox_rte_ether_addr *)&task->src_dst_mac[0], &hdr->d_addr);
else if ((task->runtime_flags & TASK_ARG_DO_NOT_SET_DST_MAC) == 0)
- ether_addr_copy(&hdr->s_addr, &hdr->d_addr);
+ prox_rte_ether_addr_copy(&hdr->s_addr, &hdr->d_addr);
if (task->runtime_flags & TASK_ARG_SRC_MAC_SET) {
- ether_addr_copy((struct ether_addr *)&task->src_dst_mac[6], &hdr->s_addr);
+ prox_rte_ether_addr_copy((prox_rte_ether_addr *)&task->src_dst_mac[6], &hdr->s_addr);
} else if ((task->runtime_flags & TASK_ARG_DO_NOT_SET_SRC_MAC) == 0) {
- ether_addr_copy(&mac, &hdr->s_addr);
+ prox_rte_ether_addr_copy(&mac, &hdr->s_addr);
}
}
}
@@ -66,7 +66,7 @@ static int handle_l2fwd_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, u
static void init_task_l2fwd(struct task_base *tbase, struct task_args *targ)
{
struct task_l2fwd *task = (struct task_l2fwd *)tbase;
- struct ether_addr *src_addr, *dst_addr;
+ prox_rte_ether_addr *src_addr, *dst_addr;
/*
* The destination MAC of the outgoing packet is based on the config file:
diff --git a/VNFs/DPPD-PROX/handle_lat.c b/VNFs/DPPD-PROX/handle_lat.c
index d3a52d7e..ef4da319 100644
--- a/VNFs/DPPD-PROX/handle_lat.c
+++ b/VNFs/DPPD-PROX/handle_lat.c
@@ -1,5 +1,5 @@
/*
-// Copyright (c) 2010-2017 Intel Corporation
+// Copyright (c) 2010-2019 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -34,7 +34,7 @@
#include "prox_shared.h"
#include "prox_port_cfg.h"
-#define DEFAULT_BUCKET_SIZE 10
+#define DEFAULT_BUCKET_SIZE 11
#define ACCURACY_BUFFER_SIZE (2 * ACCURACY_WINDOW)
struct lat_info {
@@ -60,7 +60,7 @@ struct delayed_latency_entry {
uint32_t packet_id;
uint8_t generator_id;
uint64_t pkt_rx_time;
- uint64_t pkt_tx_time;
+ uint64_t pkt_tx_time; // Time written into packets by gen. Unit is TSC >> LATENCY_ACCURACY
uint64_t rx_time_err;
};
@@ -128,6 +128,11 @@ static uint32_t diff_time(uint32_t rx_time, uint32_t tx_time)
return rx_time - tx_time;
}
+uint32_t task_lat_get_latency_bucket_size(struct task_lat *task)
+{
+ return task->lat_test->bucket_size;
+}
+
struct lat_test *task_lat_get_latency_meassurement(struct task_lat *task)
{
if (task->use_lt == task->using_lt)
@@ -453,7 +458,7 @@ static void lat_test_histogram_add(struct lat_test *lat_test, uint64_t lat_tsc)
uint64_t bucket_id = (lat_tsc >> lat_test->bucket_size);
size_t bucket_count = sizeof(lat_test->buckets)/sizeof(lat_test->buckets[0]);
- bucket_id = bucket_id < bucket_count? bucket_id : bucket_count;
+ bucket_id = bucket_id < bucket_count? bucket_id : (bucket_count - 1);
lat_test->buckets[bucket_id]++;
}
@@ -776,8 +781,8 @@ static void init_task_lat(struct task_base *tbase, struct task_args *targ)
task->lt[0].min_lat = -1;
task->lt[1].min_lat = -1;
- task->lt[0].bucket_size = targ->bucket_size - LATENCY_ACCURACY;
- task->lt[1].bucket_size = targ->bucket_size - LATENCY_ACCURACY;
+ task->lt[0].bucket_size = targ->bucket_size;
+ task->lt[1].bucket_size = targ->bucket_size;
if (task->unique_id_pos) {
task_lat_init_eld(task, socket_id);
task_lat_reset_eld(task);
@@ -792,7 +797,7 @@ static void init_task_lat(struct task_base *tbase, struct task_args *targ)
uint64_t bytes_per_hz = UINT64_MAX;
if (targ->nb_rxports) {
struct prox_port_cfg *port = &prox_port_cfg[targ->rx_port_queue[0].port];
- max_frame_size = port->mtu + ETHER_HDR_LEN + ETHER_CRC_LEN + 2 * PROX_VLAN_TAG_SIZE;
+ max_frame_size = port->mtu + PROX_RTE_ETHER_HDR_LEN + PROX_RTE_ETHER_CRC_LEN + 2 * PROX_VLAN_TAG_SIZE;
// port->max_link_speed reports the maximum, non negotiated ink speed in Mbps e.g. 40k for a 40 Gbps NIC.
// It can be UINT32_MAX (virtual devices or not supported by DPDK < 16.04)
diff --git a/VNFs/DPPD-PROX/handle_lat.h b/VNFs/DPPD-PROX/handle_lat.h
index 46f5e7d4..a80afc90 100644
--- a/VNFs/DPPD-PROX/handle_lat.h
+++ b/VNFs/DPPD-PROX/handle_lat.h
@@ -1,5 +1,5 @@
/*
-// Copyright (c) 2010-2017 Intel Corporation
+// Copyright (c) 2010-2019 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -29,6 +29,11 @@
// packet N is received (re-ordering) resulting in accuracy being unused
// 8192 packets is equivalent to 550 micro-seconds at 10Gbps for 64 bytes packets
#define ACCURACY_WINDOW 8192
+#define LAT_BUCKET_COUNT 128
+
+#define LAT_BUCKET_COUNT 128
+
+#define LAT_BUCKET_COUNT 128
struct lat_test {
uint64_t tot_all_pkts;
@@ -44,7 +49,7 @@ struct lat_test {
uint64_t tot_lat_error;
unsigned __int128 var_lat_error;
- uint64_t buckets[128];
+ uint64_t buckets[LAT_BUCKET_COUNT];
uint64_t bucket_size;
uint64_t lost_packets;
};
@@ -186,6 +191,7 @@ static void lat_test_copy(struct lat_test *dst, struct lat_test *src)
struct task_lat;
struct lat_test *task_lat_get_latency_meassurement(struct task_lat *task);
+uint32_t task_lat_get_latency_bucket_size(struct task_lat *task);
void task_lat_use_other_latency_meassurement(struct task_lat *task);
void task_lat_set_accuracy_limit(struct task_lat *task, uint32_t accuracy_limit_nsec);
diff --git a/VNFs/DPPD-PROX/handle_lb_5tuple.c b/VNFs/DPPD-PROX/handle_lb_5tuple.c
index 7aadf49a..d320ca9d 100644
--- a/VNFs/DPPD-PROX/handle_lb_5tuple.c
+++ b/VNFs/DPPD-PROX/handle_lb_5tuple.c
@@ -58,7 +58,7 @@ static inline uint8_t get_ipv4_dst_port(struct task_lb_5tuple *task, void *ipv4_
int ret = 0;
union ipv4_5tuple_host key;
- ipv4_hdr = (uint8_t *)ipv4_hdr + offsetof(struct ipv4_hdr, time_to_live);
+ ipv4_hdr = (uint8_t *)ipv4_hdr + offsetof(prox_rte_ipv4_hdr, time_to_live);
__m128i data = _mm_loadu_si128((__m128i*)(ipv4_hdr));
/* Get 5 tuple: dst port, src port, dst IP address, src IP address and protocol */
key.xmm = _mm_and_si128(data, mask0);
@@ -76,15 +76,15 @@ static inline uint8_t get_ipv4_dst_port(struct task_lb_5tuple *task, void *ipv4_
static inline uint8_t handle_lb_5tuple(struct task_lb_5tuple *task, struct rte_mbuf *mbuf)
{
- struct ether_hdr *eth_hdr;
- struct ipv4_hdr *ipv4_hdr;
+ prox_rte_ether_hdr *eth_hdr;
+ prox_rte_ipv4_hdr *ipv4_hdr;
- eth_hdr = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ eth_hdr = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
switch (eth_hdr->ether_type) {
case ETYPE_IPv4:
/* Handle IPv4 headers.*/
- ipv4_hdr = (struct ipv4_hdr *) (eth_hdr + 1);
+ ipv4_hdr = (prox_rte_ipv4_hdr *) (eth_hdr + 1);
return get_ipv4_dst_port(task, ipv4_hdr, OUT_DISCARD, task->lookup_hash);
default:
return OUT_DISCARD;
diff --git a/VNFs/DPPD-PROX/handle_lb_net.c b/VNFs/DPPD-PROX/handle_lb_net.c
index 46a7226e..1bfb6c3d 100644
--- a/VNFs/DPPD-PROX/handle_lb_net.c
+++ b/VNFs/DPPD-PROX/handle_lb_net.c
@@ -357,9 +357,9 @@ static inline uint8_t worker_from_mask(struct task_lb_net *task, uint32_t val)
static inline int extract_gre_key(struct task_lb_net_lut *task, uint32_t *key, struct rte_mbuf *mbuf)
{
// For all packets, one by one, remove MPLS tag if any and fills in keys used by "fake" packets
- struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
// Check for MPLS TAG
- struct ipv4_hdr *ip;
+ prox_rte_ipv4_hdr *ip;
if (peth->ether_type == ETYPE_MPLSU) {
struct mpls_hdr *mpls = (struct mpls_hdr *)(peth + 1);
uint32_t mpls_len = 0;
@@ -368,12 +368,12 @@ static inline int extract_gre_key(struct task_lb_net_lut *task, uint32_t *key, s
mpls_len += sizeof(struct mpls_hdr);
}
mpls_len += sizeof(struct mpls_hdr);
- ip = (struct ipv4_hdr *)(mpls + 1);
+ ip = (prox_rte_ipv4_hdr *)(mpls + 1);
switch (ip->version_ihl >> 4) {
case 4:
// Remove MPLS Tag if requested
if (task->runtime_flags & TASK_MPLS_TAGGING) {
- peth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, mpls_len);
+ peth = (prox_rte_ether_hdr *)rte_pktmbuf_adj(mbuf, mpls_len);
peth->ether_type = ETYPE_IPv4;
}
break;
@@ -386,7 +386,7 @@ static inline int extract_gre_key(struct task_lb_net_lut *task, uint32_t *key, s
}
}
else {
- ip = (struct ipv4_hdr *)(peth + 1);
+ ip = (prox_rte_ipv4_hdr *)(peth + 1);
}
// Entry point for the packet => check for packet validity
// => do not use extract_key_core(mbufs[j], &task->keys[j]);
@@ -416,7 +416,7 @@ static inline int extract_gre_key(struct task_lb_net_lut *task, uint32_t *key, s
return 0;
}
-static inline uint8_t lb_ip4(struct task_lb_net *task, struct ipv4_hdr *ip)
+static inline uint8_t lb_ip4(struct task_lb_net *task, prox_rte_ipv4_hdr *ip)
{
if (unlikely(ip->version_ihl >> 4 != 4)) {
plog_warn("Expected to receive IPv4 packet but IP version was %d\n",
@@ -453,7 +453,7 @@ static inline uint8_t lb_ip4(struct task_lb_net *task, struct ipv4_hdr *ip)
return OUT_DISCARD;
}
-static inline uint8_t lb_ip6(struct task_lb_net *task, struct ipv6_hdr *ip)
+static inline uint8_t lb_ip6(struct task_lb_net *task, prox_rte_ipv6_hdr *ip)
{
if (unlikely((*(uint8_t*)ip) >> 4 != 6)) {
plog_warn("Expected to receive IPv6 packet but IP version was %d\n",
@@ -465,7 +465,7 @@ static inline uint8_t lb_ip6(struct task_lb_net *task, struct ipv6_hdr *ip)
return worker + task->nb_worker_threads * IPV6;
}
-static inline uint8_t lb_mpls(struct task_lb_net *task, struct ether_hdr *peth, struct rte_mbuf *mbuf)
+static inline uint8_t lb_mpls(struct task_lb_net *task, prox_rte_ether_hdr *peth, struct rte_mbuf *mbuf)
{
struct mpls_hdr *mpls = (struct mpls_hdr *)(peth + 1);
uint32_t mpls_len = 0;
@@ -474,21 +474,21 @@ static inline uint8_t lb_mpls(struct task_lb_net *task, struct ether_hdr *peth,
mpls_len += sizeof(struct mpls_hdr);
}
mpls_len += sizeof(struct mpls_hdr);
- struct ipv4_hdr *ip = (struct ipv4_hdr *)(mpls + 1);
+ prox_rte_ipv4_hdr *ip = (prox_rte_ipv4_hdr *)(mpls + 1);
switch (ip->version_ihl >> 4) {
case 4:
if (task->runtime_flags & TASK_MPLS_TAGGING) {
- peth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, mpls_len);
+ peth = (prox_rte_ether_hdr *)rte_pktmbuf_adj(mbuf, mpls_len);
peth->ether_type = ETYPE_IPv4;
}
return lb_ip4(task, ip);
case 6:
if (task->runtime_flags & TASK_MPLS_TAGGING) {
- peth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, mpls_len);
+ peth = (prox_rte_ether_hdr *)rte_pktmbuf_adj(mbuf, mpls_len);
peth->ether_type = ETYPE_IPv6;
}
- return lb_ip6(task, (struct ipv6_hdr *)ip);
+ return lb_ip6(task, (prox_rte_ipv6_hdr *)ip);
default:
plogd_warn(mbuf, "Failed Decoding MPLS Packet - neither IPv4 neither IPv6: version %u for packet : \n", ip->version_ihl);
return OUT_DISCARD;
@@ -507,7 +507,7 @@ static inline uint8_t lb_qinq(struct task_lb_net *task, struct qinq_hdr *qinq)
static inline uint8_t handle_lb_net(struct task_lb_net *task, struct rte_mbuf *mbuf)
{
- struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
const uint16_t len = rte_pktmbuf_pkt_len(mbuf);
if (len < 60) {
plogd_warn(mbuf, "Unexpected frame len = %d for packet : \n", len);
@@ -520,9 +520,9 @@ static inline uint8_t handle_lb_net(struct task_lb_net *task, struct rte_mbuf *m
case ETYPE_8021ad:
return lb_qinq(task, (struct qinq_hdr *)peth);
case ETYPE_IPv4:
- return lb_ip4(task, (struct ipv4_hdr *)(peth + 1));
+ return lb_ip4(task, (prox_rte_ipv4_hdr *)(peth + 1));
case ETYPE_IPv6:
- return lb_ip6(task, (struct ipv6_hdr *)(peth + 1));
+ return lb_ip6(task, (prox_rte_ipv6_hdr *)(peth + 1));
case ETYPE_LLDP:
return OUT_DISCARD;
default:
diff --git a/VNFs/DPPD-PROX/handle_lb_pos.c b/VNFs/DPPD-PROX/handle_lb_pos.c
index 4324e94d..3cf465ce 100644
--- a/VNFs/DPPD-PROX/handle_lb_pos.c
+++ b/VNFs/DPPD-PROX/handle_lb_pos.c
@@ -81,9 +81,9 @@ union ip_port {
};
struct pkt_ether_ipv4_udp {
- struct ether_hdr ether;
- struct ipv4_hdr ipv4;
- struct udp_hdr udp;
+ prox_rte_ether_hdr ether;
+ prox_rte_ipv4_hdr ipv4;
+ prox_rte_udp_hdr udp;
} __attribute__((unused));
static uint8_t handle_lb_ip_port(struct task_lb_pos *task, struct rte_mbuf *mbuf)
diff --git a/VNFs/DPPD-PROX/handle_lb_qinq.c b/VNFs/DPPD-PROX/handle_lb_qinq.c
index 18ff7df4..49ed1b79 100644
--- a/VNFs/DPPD-PROX/handle_lb_qinq.c
+++ b/VNFs/DPPD-PROX/handle_lb_qinq.c
@@ -245,22 +245,22 @@ int handle_lb_qinq_bulk_set_port(struct task_base *tbase, struct rte_mbuf **mbuf
struct qinq_packet {
struct qinq_hdr qinq_hdr;
union {
- struct ipv4_hdr ipv4_hdr;
- struct ipv6_hdr ipv6_hdr;
+ prox_rte_ipv4_hdr ipv4_hdr;
+ prox_rte_ipv6_hdr ipv6_hdr;
};
} __attribute__((packed));
struct qinq_packet_data {
- struct ether_addr d_addr;
- struct ether_addr s_addr;
+ prox_rte_ether_addr d_addr;
+ prox_rte_ether_addr s_addr;
uint64_t qinq;
} __attribute__((packed));
struct ether_packet {
- struct ether_hdr ether_hdr;
+ prox_rte_ether_hdr ether_hdr;
union {
- struct ipv4_hdr ipv4_hdr;
- struct ipv6_hdr ipv6_hdr;
+ prox_rte_ipv4_hdr ipv4_hdr;
+ prox_rte_ipv6_hdr ipv6_hdr;
};
} __attribute__((packed));
diff --git a/VNFs/DPPD-PROX/handle_master.c b/VNFs/DPPD-PROX/handle_master.c
index c6ae96b1..9a864352 100644
--- a/VNFs/DPPD-PROX/handle_master.c
+++ b/VNFs/DPPD-PROX/handle_master.c
@@ -56,18 +56,18 @@ static struct my_arp_t arp_request = {
};
struct ip_table {
- struct ether_addr mac;
+ prox_rte_ether_addr mac;
struct rte_ring *ring;
};
struct external_ip_table {
- struct ether_addr mac;
+ prox_rte_ether_addr mac;
struct rte_ring *rings[PROX_MAX_ARP_REQUESTS];
uint16_t nb_requests;
};
struct port_table {
- struct ether_addr mac;
+ prox_rte_ether_addr mac;
struct rte_ring *ring;
uint32_t ip;
uint8_t port;
@@ -187,7 +187,7 @@ static inline void handle_arp_request(struct task_base *tbase, struct rte_mbuf *
key.ip = hdr_arp->arp.data.tpa;
key.port = port;
if (task->internal_port_table[port].flags & HANDLE_RANDOM_IP_FLAG) {
- struct ether_addr mac;
+ prox_rte_ether_addr mac;
plogx_dbg("\tMaster handling ARP request for ip %d.%d.%d.%d on port %d which supports random ip\n", IP4(key.ip), key.port);
struct rte_ring *ring = task->internal_port_table[port].ring;
create_mac(hdr_arp, &mac);
diff --git a/VNFs/DPPD-PROX/handle_mplstag.c b/VNFs/DPPD-PROX/handle_mplstag.c
index ce5996eb..ed122a06 100644
--- a/VNFs/DPPD-PROX/handle_mplstag.c
+++ b/VNFs/DPPD-PROX/handle_mplstag.c
@@ -42,23 +42,23 @@ static void init_task_unmpls(__attribute__((unused)) struct task_base *tbase,
static inline uint8_t handle_unmpls(__attribute__((unused)) struct task_unmpls *task, struct rte_mbuf *mbuf)
{
- struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
struct mpls_hdr *mpls = (struct mpls_hdr *)(peth + 1);
uint32_t mpls_len = sizeof(struct mpls_hdr);
while (!(mpls->bytes & 0x00010000)) {
mpls++;
mpls_len += sizeof(struct mpls_hdr);
}
- uint32_t tot_eth_addr_len = 2*sizeof(struct ether_addr);
+ uint32_t tot_eth_addr_len = 2*sizeof(prox_rte_ether_addr);
rte_memcpy(((uint8_t *)peth) + mpls_len, peth, tot_eth_addr_len);
- struct ipv4_hdr *ip = (struct ipv4_hdr *)(mpls + 1);
+ prox_rte_ipv4_hdr *ip = (prox_rte_ipv4_hdr *)(mpls + 1);
switch (ip->version_ihl >> 4) {
case 4:
- peth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, mpls_len);
+ peth = (prox_rte_ether_hdr *)rte_pktmbuf_adj(mbuf, mpls_len);
peth->ether_type = ETYPE_IPv4;
return 0;
case 6:
- peth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, mpls_len);
+ peth = (prox_rte_ether_hdr *)rte_pktmbuf_adj(mbuf, mpls_len);
peth->ether_type = ETYPE_IPv6;
return 0;
default:
@@ -109,12 +109,12 @@ static void init_task_tagmpls(__attribute__((unused)) struct task_base *tbase,
static inline uint8_t handle_tagmpls(__attribute__((unused)) struct task_tagmpls *task, struct rte_mbuf *mbuf)
{
- struct ether_hdr *peth = (struct ether_hdr *)rte_pktmbuf_prepend(mbuf, 4);
+ prox_rte_ether_hdr *peth = (prox_rte_ether_hdr *)rte_pktmbuf_prepend(mbuf, 4);
PROX_ASSERT(peth);
rte_prefetch0(peth);
uint32_t mpls = 0;
- uint32_t tot_eth_addr_len = 2*sizeof(struct ether_addr);
+ uint32_t tot_eth_addr_len = 2*sizeof(prox_rte_ether_addr);
rte_memcpy(peth, ((uint8_t *)peth) + sizeof(struct mpls_hdr), tot_eth_addr_len);
*((uint32_t *)(peth + 1)) = mpls | 0x00010000; // Set BoS to 1
peth->ether_type = ETYPE_MPLSU;
diff --git a/VNFs/DPPD-PROX/handle_nat.c b/VNFs/DPPD-PROX/handle_nat.c
index 8e6789a4..4cd2de22 100644
--- a/VNFs/DPPD-PROX/handle_nat.c
+++ b/VNFs/DPPD-PROX/handle_nat.c
@@ -45,8 +45,8 @@ struct task_nat {
};
struct pkt_eth_ipv4 {
- struct ether_hdr ether_hdr;
- struct ipv4_hdr ipv4_hdr;
+ prox_rte_ether_hdr ether_hdr;
+ prox_rte_ipv4_hdr ipv4_hdr;
} __attribute__((packed));
static int handle_nat(struct task_nat *task, struct rte_mbuf *mbuf)
@@ -71,7 +71,7 @@ static int handle_nat(struct task_nat *task, struct rte_mbuf *mbuf)
return OUT_DISCARD;
*ip_addr = task->entries[ret];
- prox_ip_udp_cksum(mbuf, &pkt->ipv4_hdr, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+ prox_ip_udp_cksum(mbuf, &pkt->ipv4_hdr, sizeof(prox_rte_ether_hdr), sizeof(prox_rte_ipv4_hdr), task->offload_crc);
return 0;
}
diff --git a/VNFs/DPPD-PROX/handle_nsh.c b/VNFs/DPPD-PROX/handle_nsh.c
index dbd0e655..c9474255 100644
--- a/VNFs/DPPD-PROX/handle_nsh.c
+++ b/VNFs/DPPD-PROX/handle_nsh.c
@@ -27,7 +27,7 @@
#include "prefetch.h"
#include "log.h"
-#define VXLAN_GPE_HDR_SZ sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr) + sizeof(struct vxlan_gpe_hdr) + sizeof(struct nsh_hdr)
+#define VXLAN_GPE_HDR_SZ sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr) + sizeof(prox_rte_udp_hdr) + sizeof(prox_rte_vxlan_gpe_hdr) + sizeof(struct nsh_hdr)
#define ETHER_NSH_TYPE 0x4F89 /* 0x894F in little endian */
#define VXLAN_GPE_NSH_TYPE 0xB612 /* 4790 in little endian */
#define VXLAN_GPE_NP 0x4
@@ -51,15 +51,15 @@ static void init_task_decap_nsh(__attribute__((unused)) struct task_base *tbase,
static inline uint8_t handle_decap_nsh(__attribute__((unused)) struct task_decap_nsh *task, struct rte_mbuf *mbuf)
{
- struct ether_hdr *eth_hdr = NULL;
- struct udp_hdr *udp_hdr = NULL;
- struct vxlan_gpe_hdr *vxlan_gpe_hdr = NULL;
+ prox_rte_ether_hdr *eth_hdr = NULL;
+ prox_rte_udp_hdr *udp_hdr = NULL;
+ prox_rte_vxlan_gpe_hdr *vxlan_gpe_hdr = NULL;
uint16_t hdr_len;
- eth_hdr = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ eth_hdr = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
if (eth_hdr->ether_type == ETHER_NSH_TYPE) {
/* "decapsulate" Ethernet + NSH header by moving packet pointer */
- hdr_len = sizeof(struct ether_hdr) + sizeof(struct nsh_hdr);
+ hdr_len = sizeof(prox_rte_ether_hdr) + sizeof(struct nsh_hdr);
mbuf->data_len = (uint16_t)(mbuf->data_len - hdr_len);
mbuf->data_off += hdr_len;
@@ -74,14 +74,14 @@ static inline uint8_t handle_decap_nsh(__attribute__((unused)) struct task_decap
}
/* check the UDP destination port */
- udp_hdr = (struct udp_hdr *)(((unsigned char *)eth_hdr) + sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr));
+ udp_hdr = (prox_rte_udp_hdr *)(((unsigned char *)eth_hdr) + sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr));
if (udp_hdr->dst_port != VXLAN_GPE_NSH_TYPE) {
mbuf->udata64 = 0;
return 0;
}
/* check the Next Protocol field in VxLAN-GPE header */
- vxlan_gpe_hdr = (struct vxlan_gpe_hdr *)(((unsigned char *)eth_hdr) + sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr));
+ vxlan_gpe_hdr = (prox_rte_vxlan_gpe_hdr *)(((unsigned char *)eth_hdr) + sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr) + sizeof(prox_rte_udp_hdr));
if (vxlan_gpe_hdr->proto != VXLAN_GPE_NP) {
mbuf->udata64 = 0;
return 0;
@@ -131,10 +131,10 @@ static void init_task_encap_nsh(__attribute__((unused)) struct task_base *tbase,
static inline uint8_t handle_encap_nsh(__attribute__((unused)) struct task_encap_nsh *task, struct rte_mbuf *mbuf)
{
- struct ether_hdr *eth_hdr = NULL;
+ prox_rte_ether_hdr *eth_hdr = NULL;
struct nsh_hdr *nsh_hdr = NULL;
- struct udp_hdr *udp_hdr = NULL;
- struct vxlan_gpe_hdr *vxlan_gpe_hdr = NULL;
+ prox_rte_udp_hdr *udp_hdr = NULL;
+ prox_rte_vxlan_gpe_hdr *vxlan_gpe_hdr = NULL;
uint16_t hdr_len;
if (mbuf == NULL)
@@ -148,9 +148,9 @@ static inline uint8_t handle_encap_nsh(__attribute__((unused)) struct task_encap
mbuf->data_off -= mbuf->udata64;
mbuf->pkt_len = (uint32_t)(mbuf->pkt_len + mbuf->udata64);
- eth_hdr = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ eth_hdr = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
if (eth_hdr->ether_type == ETHER_NSH_TYPE) {
- nsh_hdr = (struct nsh_hdr *) (((unsigned char *)eth_hdr) + sizeof(struct ether_hdr));
+ nsh_hdr = (struct nsh_hdr *) (((unsigned char *)eth_hdr) + sizeof(prox_rte_ether_hdr));
/* decrement Service Index in NSH header */
if (nsh_hdr->sf_index > 0)
@@ -162,17 +162,17 @@ static inline uint8_t handle_encap_nsh(__attribute__((unused)) struct task_encap
return 0;
/* check the UDP destination port */
- udp_hdr = (struct udp_hdr *)(((unsigned char *)eth_hdr) + sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr));
+ udp_hdr = (prox_rte_udp_hdr *)(((unsigned char *)eth_hdr) + sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr));
if (udp_hdr->dst_port != VXLAN_GPE_NSH_TYPE)
return 0;
/* check the Next Protocol field in VxLAN-GPE header */
- vxlan_gpe_hdr = (struct vxlan_gpe_hdr *)(((unsigned char *)eth_hdr) + sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr) + sizeof(struct udp_hdr));
+ vxlan_gpe_hdr = (prox_rte_vxlan_gpe_hdr *)(((unsigned char *)eth_hdr) + sizeof(prox_rte_ether_hdr) + sizeof(prox_rte_ipv4_hdr) + sizeof(prox_rte_udp_hdr));
if (vxlan_gpe_hdr->proto != VXLAN_GPE_NP)
return 0;
/* decrement Service Index in NSH header */
- nsh_hdr = (struct nsh_hdr *)(((unsigned char *)vxlan_gpe_hdr) + sizeof(struct vxlan_gpe_hdr));
+ nsh_hdr = (struct nsh_hdr *)(((unsigned char *)vxlan_gpe_hdr) + sizeof(prox_rte_vxlan_gpe_hdr));
if (nsh_hdr->sf_index > 0)
nsh_hdr->sf_index -= 1;
}
diff --git a/VNFs/DPPD-PROX/handle_qinq_decap4.c b/VNFs/DPPD-PROX/handle_qinq_decap4.c
index 767c0d17..94efbb1f 100644
--- a/VNFs/DPPD-PROX/handle_qinq_decap4.c
+++ b/VNFs/DPPD-PROX/handle_qinq_decap4.c
@@ -380,9 +380,9 @@ static int handle_qinq_decap4_bulk(struct task_base *tbase, struct rte_mbuf **mb
static inline void gre_encap(struct task_qinq_decap4 *task, uint32_t src_ipv4, struct rte_mbuf *mbuf, uint32_t gre_id)
{
#ifdef USE_QINQ
- struct ipv4_hdr *pip = (struct ipv4_hdr *)(1 + rte_pktmbuf_mtod(mbuf, struct qinq_hdr *));
+ prox_rte_ipv4_hdr *pip = (prox_rte_ipv4_hdr *)(1 + rte_pktmbuf_mtod(mbuf, struct qinq_hdr *));
#else
- struct ipv4_hdr *pip = (struct ipv4_hdr *)(1 + rte_pktmbuf_mtod(mbuf, struct ether_hdr *));
+ prox_rte_ipv4_hdr *pip = (prox_rte_ipv4_hdr *)(1 + rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *));
#endif
uint16_t ip_len = rte_be_to_cpu_16(pip->total_length);
uint16_t padlen = rte_pktmbuf_pkt_len(mbuf) - 20 - ip_len - sizeof(struct qinq_hdr);
@@ -391,15 +391,15 @@ static inline void gre_encap(struct task_qinq_decap4 *task, uint32_t src_ipv4, s
rte_pktmbuf_trim(mbuf, padlen);
}
- PROX_PANIC(rte_pktmbuf_data_len(mbuf) - padlen + 20 > ETHER_MAX_LEN,
+ PROX_PANIC(rte_pktmbuf_data_len(mbuf) - padlen + 20 > PROX_RTE_ETHER_MAX_LEN,
"Would need to fragment packet new size = %u - not implemented\n",
rte_pktmbuf_data_len(mbuf) - padlen + 20);
#ifdef USE_QINQ
/* prepend only 20 bytes instead of 28, 8 bytes are present from the QinQ */
- struct ether_hdr *peth = (struct ether_hdr *)rte_pktmbuf_prepend(mbuf, 20);
+ prox_rte_ether_hdr *peth = (prox_rte_ether_hdr *)rte_pktmbuf_prepend(mbuf, 20);
#else
- struct ether_hdr *peth = (struct ether_hdr *)rte_pktmbuf_prepend(mbuf, 28);
+ prox_rte_ether_hdr *peth = (prox_rte_ether_hdr *)rte_pktmbuf_prepend(mbuf, 28);
#endif
PROX_ASSERT(peth);
@@ -407,16 +407,16 @@ static inline void gre_encap(struct task_qinq_decap4 *task, uint32_t src_ipv4, s
if (task->runtime_flags & TASK_TX_CRC) {
/* calculate IP CRC here to avoid problems with -O3 flag with gcc */
#ifdef MPLS_ROUTING
- prox_ip_cksum(mbuf, pip, sizeof(struct ether_hdr) + sizeof(struct mpls_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+ prox_ip_cksum(mbuf, pip, sizeof(prox_rte_ether_hdr) + sizeof(struct mpls_hdr), sizeof(prox_rte_ipv4_hdr), task->offload_crc);
#else
- prox_ip_cksum(mbuf, pip, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+ prox_ip_cksum(mbuf, pip, sizeof(prox_rte_ether_hdr), sizeof(prox_rte_ipv4_hdr), task->offload_crc);
#endif
}
/* new IP header */
- struct ipv4_hdr *p_tunnel_ip = (struct ipv4_hdr *)(peth + 1);
- rte_memcpy(p_tunnel_ip, &tunnel_ip_proto, sizeof(struct ipv4_hdr));
- ip_len += sizeof(struct ipv4_hdr) + sizeof(struct gre_hdr);
+ prox_rte_ipv4_hdr *p_tunnel_ip = (prox_rte_ipv4_hdr *)(peth + 1);
+ rte_memcpy(p_tunnel_ip, &tunnel_ip_proto, sizeof(prox_rte_ipv4_hdr));
+ ip_len += sizeof(prox_rte_ipv4_hdr) + sizeof(struct gre_hdr);
p_tunnel_ip->total_length = rte_cpu_to_be_16(ip_len);
p_tunnel_ip->src_addr = src_ipv4;
@@ -435,7 +435,7 @@ static inline uint16_t calc_padlen(const struct rte_mbuf *mbuf, const uint16_t i
static inline uint8_t gre_encap_route(uint32_t src_ipv4, struct rte_mbuf *mbuf, uint32_t gre_id, struct task_qinq_decap4 *task)
{
- PROX_PANIC(rte_pktmbuf_data_len(mbuf) + DOWNSTREAM_DELTA > ETHER_MAX_LEN,
+ PROX_PANIC(rte_pktmbuf_data_len(mbuf) + DOWNSTREAM_DELTA > PROX_RTE_ETHER_MAX_LEN,
"Would need to fragment packet new size = %u - not implemented\n",
rte_pktmbuf_data_len(mbuf) + DOWNSTREAM_DELTA);
@@ -443,7 +443,7 @@ static inline uint8_t gre_encap_route(uint32_t src_ipv4, struct rte_mbuf *mbuf,
PROX_ASSERT(packet);
PREFETCH0(packet);
- struct ipv4_hdr *pip = &((struct cpe_pkt_delta *)packet)->pkt.ipv4_hdr;
+ prox_rte_ipv4_hdr *pip = &((struct cpe_pkt_delta *)packet)->pkt.ipv4_hdr;
uint16_t ip_len = rte_be_to_cpu_16(pip->total_length);
/* returns 0 on success, returns -ENOENT of failure (or -EINVAL if first or last parameter is NULL) */
@@ -476,16 +476,16 @@ static inline uint8_t gre_encap_route(uint32_t src_ipv4, struct rte_mbuf *mbuf,
#endif
/* New IP header */
- rte_memcpy(&packet->tunnel_ip_hdr, &tunnel_ip_proto, sizeof(struct ipv4_hdr));
- ip_len += sizeof(struct ipv4_hdr) + sizeof(struct gre_hdr);
+ rte_memcpy(&packet->tunnel_ip_hdr, &tunnel_ip_proto, sizeof(prox_rte_ipv4_hdr));
+ ip_len += sizeof(prox_rte_ipv4_hdr) + sizeof(struct gre_hdr);
packet->tunnel_ip_hdr.total_length = rte_cpu_to_be_16(ip_len);
packet->tunnel_ip_hdr.src_addr = src_ipv4;
packet->tunnel_ip_hdr.dst_addr = task->next_hops[next_hop_index].ip_dst;
if (task->runtime_flags & TASK_TX_CRC) {
#ifdef MPLS_ROUTING
- prox_ip_cksum(mbuf, (void *)&(packet->tunnel_ip_hdr), sizeof(struct ether_hdr) + sizeof(struct mpls_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+ prox_ip_cksum(mbuf, (void *)&(packet->tunnel_ip_hdr), sizeof(prox_rte_ether_hdr) + sizeof(struct mpls_hdr), sizeof(prox_rte_ipv4_hdr), task->offload_crc);
#else
- prox_ip_cksum(mbuf, (void *)&(packet->tunnel_ip_hdr), sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+ prox_ip_cksum(mbuf, (void *)&(packet->tunnel_ip_hdr), sizeof(prox_rte_ether_hdr), sizeof(prox_rte_ipv4_hdr), task->offload_crc);
#endif
}
diff --git a/VNFs/DPPD-PROX/handle_qinq_decap6.c b/VNFs/DPPD-PROX/handle_qinq_decap6.c
index 77bacb75..d26f312a 100644
--- a/VNFs/DPPD-PROX/handle_qinq_decap6.c
+++ b/VNFs/DPPD-PROX/handle_qinq_decap6.c
@@ -45,7 +45,7 @@ struct task_qinq_decap6 {
struct rte_table_hash *cpe_table;
uint16_t *user_table;
uint32_t bucket_index;
- struct ether_addr edaddr;
+ prox_rte_ether_addr edaddr;
struct rte_lpm6 *rte_lpm6;
void* period_data; /* used if using dual stack*/
void (*period_func)(void* data);
@@ -103,7 +103,7 @@ static void early_init(struct task_args *targ)
static inline uint8_t handle_qinq_decap6(struct task_qinq_decap6 *task, struct rte_mbuf *mbuf)
{
struct qinq_hdr *pqinq = rte_pktmbuf_mtod(mbuf, struct qinq_hdr *);
- struct ipv6_hdr *pip6 = (struct ipv6_hdr *)(pqinq + 1);
+ prox_rte_ipv6_hdr *pip6 = (prox_rte_ipv6_hdr *)(pqinq + 1);
uint16_t svlan = pqinq->svlan.vlan_tci & 0xFF0F;
uint16_t cvlan = pqinq->cvlan.vlan_tci & 0xFF0F;
@@ -124,11 +124,11 @@ static inline uint8_t handle_qinq_decap6(struct task_qinq_decap6 *task, struct r
return OUT_DISCARD;
}
- pqinq = (struct qinq_hdr *)rte_pktmbuf_adj(mbuf, 2 * sizeof(struct vlan_hdr));
+ pqinq = (struct qinq_hdr *)rte_pktmbuf_adj(mbuf, 2 * sizeof(prox_rte_vlan_hdr));
PROX_ASSERT(pqinq);
pqinq->ether_type = ETYPE_IPv6;
// Dest MAC addresses
- ether_addr_copy(&task->edaddr, &pqinq->d_addr);
+ prox_rte_ether_addr_copy(&task->edaddr, &pqinq->d_addr);
return 0;
}
diff --git a/VNFs/DPPD-PROX/handle_qinq_encap4.c b/VNFs/DPPD-PROX/handle_qinq_encap4.c
index e5c16af4..ffd9356a 100644
--- a/VNFs/DPPD-PROX/handle_qinq_encap4.c
+++ b/VNFs/DPPD-PROX/handle_qinq_encap4.c
@@ -444,14 +444,14 @@ static int handle_qinq_encap4_bulk_pe(struct task_base *tbase, struct rte_mbuf *
prefetch_pkts(mbufs, n_pkts);
for (uint16_t j = 0; j < n_pkts; ++j) {
- struct ipv4_hdr* ip = (struct ipv4_hdr *)(rte_pktmbuf_mtod(mbufs[j], struct ether_hdr *) + 1);
+ prox_rte_ipv4_hdr* ip = (prox_rte_ipv4_hdr *)(rte_pktmbuf_mtod(mbufs[j], prox_rte_ether_hdr *) + 1);
task->keys[j] = (uint64_t)ip->dst_addr;
}
prox_rte_table_key8_lookup(task->cpe_table, task->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) {
- struct cpe_pkt* cpe_pkt = (struct cpe_pkt*) rte_pktmbuf_prepend(mbufs[j], sizeof(struct qinq_hdr) - sizeof(struct ether_hdr));
+ struct cpe_pkt* cpe_pkt = (struct cpe_pkt*) rte_pktmbuf_prepend(mbufs[j], sizeof(struct qinq_hdr) - sizeof(prox_rte_ether_hdr));
uint16_t padlen = mbuf_calc_padlen(mbufs[j], cpe_pkt, &cpe_pkt->ipv4_hdr);
if (padlen) {
@@ -467,7 +467,7 @@ static int handle_qinq_encap4_bulk_pe(struct task_base *tbase, struct rte_mbuf *
out[j] = OUT_DISCARD;
continue;
}
- struct cpe_pkt* cpe_pkt = (struct cpe_pkt*) rte_pktmbuf_prepend(mbufs[j], sizeof(struct qinq_hdr) - sizeof(struct ether_hdr));
+ struct cpe_pkt* cpe_pkt = (struct cpe_pkt*) rte_pktmbuf_prepend(mbufs[j], sizeof(struct qinq_hdr) - sizeof(prox_rte_ether_hdr));
uint16_t padlen = mbuf_calc_padlen(mbufs[j], cpe_pkt, &cpe_pkt->ipv4_hdr);
if (padlen) {
@@ -551,7 +551,7 @@ static inline uint8_t handle_qinq_encap4(struct task_qinq_encap4 *task, struct c
task->stats_per_user[entry->user]++;
#endif
if (task->runtime_flags & TASK_TX_CRC) {
- prox_ip_cksum(mbuf, &cpe_pkt->ipv4_hdr, sizeof(struct qinq_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+ prox_ip_cksum(mbuf, &cpe_pkt->ipv4_hdr, sizeof(struct qinq_hdr), sizeof(prox_rte_ipv4_hdr), task->offload_crc);
}
return entry->mac_port.out_idx;
}
diff --git a/VNFs/DPPD-PROX/handle_qinq_encap4.h b/VNFs/DPPD-PROX/handle_qinq_encap4.h
index b18b0ca6..999abbd8 100644
--- a/VNFs/DPPD-PROX/handle_qinq_encap4.h
+++ b/VNFs/DPPD-PROX/handle_qinq_encap4.h
@@ -70,20 +70,20 @@ void init_cpe4_hash(struct task_args *targ);
static inline uint8_t mpls_untag(struct rte_mbuf *mbuf)
{
- struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
const uint16_t eth_type = peth->ether_type;
if (eth_type == ETYPE_MPLSU) {
- struct ether_hdr *pneweth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, 4);
+ prox_rte_ether_hdr *pneweth = (prox_rte_ether_hdr *)rte_pktmbuf_adj(mbuf, 4);
const struct mpls_hdr *mpls = (const struct mpls_hdr *)(peth + 1);
if (mpls->bos == 0) {
// Double MPLS tag
- pneweth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, 4);
+ pneweth = (prox_rte_ether_hdr *)rte_pktmbuf_adj(mbuf, 4);
PROX_ASSERT(pneweth);
}
- const struct ipv4_hdr *pip = (const struct ipv4_hdr *)(pneweth + 1);
+ const prox_rte_ipv4_hdr *pip = (const prox_rte_ipv4_hdr *)(pneweth + 1);
if ((pip->version_ihl >> 4) == 4) {
pneweth->ether_type = ETYPE_IPv4;
return 1;
diff --git a/VNFs/DPPD-PROX/handle_qinq_encap6.c b/VNFs/DPPD-PROX/handle_qinq_encap6.c
index b0245cb7..c6538655 100644
--- a/VNFs/DPPD-PROX/handle_qinq_encap6.c
+++ b/VNFs/DPPD-PROX/handle_qinq_encap6.c
@@ -57,10 +57,10 @@ static void init_task_qinq_encap6(struct task_base *tbase, struct task_args *tar
/* Encapsulate IPv6 packet in QinQ where the QinQ is derived from the IPv6 address */
static inline uint8_t handle_qinq_encap6(struct rte_mbuf *mbuf, struct task_qinq_encap6 *task)
{
- struct qinq_hdr *pqinq = (struct qinq_hdr *)rte_pktmbuf_prepend(mbuf, 2 * sizeof(struct vlan_hdr));
+ struct qinq_hdr *pqinq = (struct qinq_hdr *)rte_pktmbuf_prepend(mbuf, 2 * sizeof(prox_rte_vlan_hdr));
PROX_ASSERT(pqinq);
- struct ipv6_hdr *pip6 = (struct ipv6_hdr *)(pqinq + 1);
+ prox_rte_ipv6_hdr *pip6 = (prox_rte_ipv6_hdr *)(pqinq + 1);
if (pip6->hop_limits) {
pip6->hop_limits--;
diff --git a/VNFs/DPPD-PROX/handle_qos.c b/VNFs/DPPD-PROX/handle_qos.c
index f6878f7b..5af7a310 100644
--- a/VNFs/DPPD-PROX/handle_qos.c
+++ b/VNFs/DPPD-PROX/handle_qos.c
@@ -76,7 +76,7 @@ static inline int handle_qos_bulk(struct task_base *tbase, struct rte_mbuf **mbu
const struct qinq_hdr *pqinq = rte_pktmbuf_mtod(mbufs[j], const struct qinq_hdr *);
uint32_t qinq = PKT_TO_LUTQINQ(pqinq->svlan.vlan_tci, pqinq->cvlan.vlan_tci);
if (pqinq->ether_type == ETYPE_IPv4) {
- const struct ipv4_hdr *ipv4_hdr = (const struct ipv4_hdr *)(pqinq + 1);
+ const prox_rte_ipv4_hdr *ipv4_hdr = (const prox_rte_ipv4_hdr *)(pqinq + 1);
queue = task->dscp[ipv4_hdr->type_of_service >> 2] & 0x3;
tc = task->dscp[ipv4_hdr->type_of_service >> 2] >> 2;
} else {
@@ -92,7 +92,7 @@ static inline int handle_qos_bulk(struct task_base *tbase, struct rte_mbuf **mbu
const struct qinq_hdr *pqinq = rte_pktmbuf_mtod(mbufs[j], const struct qinq_hdr *);
uint32_t qinq = PKT_TO_LUTQINQ(pqinq->svlan.vlan_tci, pqinq->cvlan.vlan_tci);
if (pqinq->ether_type == ETYPE_IPv4) {
- const struct ipv4_hdr *ipv4_hdr = (const struct ipv4_hdr *)(pqinq + 1);
+ const prox_rte_ipv4_hdr *ipv4_hdr = (const prox_rte_ipv4_hdr *)(pqinq + 1);
queue = task->dscp[ipv4_hdr->type_of_service >> 2] & 0x3;
tc = task->dscp[ipv4_hdr->type_of_service >> 2] >> 2;
} else {
diff --git a/VNFs/DPPD-PROX/handle_routing.c b/VNFs/DPPD-PROX/handle_routing.c
index fc9b47dd..29b84382 100644
--- a/VNFs/DPPD-PROX/handle_routing.c
+++ b/VNFs/DPPD-PROX/handle_routing.c
@@ -178,14 +178,14 @@ static int handle_routing_bulk(struct task_base *tbase, struct rte_mbuf **mbufs,
static void set_l2(struct task_routing *task, struct rte_mbuf *mbuf, uint8_t nh_idx)
{
- struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
*((uint64_t *)(&peth->d_addr)) = task->next_hops[nh_idx].mac_port_8bytes;
*((uint64_t *)(&peth->s_addr)) = task->src_mac[task->next_hops[nh_idx].mac_port.out_idx];
}
static void set_l2_mpls(struct task_routing *task, struct rte_mbuf *mbuf, uint8_t nh_idx)
{
- struct ether_hdr *peth = (struct ether_hdr *)rte_pktmbuf_prepend(mbuf, sizeof(struct mpls_hdr));
+ prox_rte_ether_hdr *peth = (prox_rte_ether_hdr *)rte_pktmbuf_prepend(mbuf, sizeof(struct mpls_hdr));
*((uint64_t *)(&peth->d_addr)) = task->next_hops[nh_idx].mac_port_8bytes;
*((uint64_t *)(&peth->s_addr)) = task->src_mac[task->next_hops[nh_idx].mac_port.out_idx];
@@ -203,8 +203,8 @@ static void set_l2_mpls(struct task_routing *task, struct rte_mbuf *mbuf, uint8_
static uint8_t route_ipv4(struct task_routing *task, uint8_t *beg, uint32_t ip_offset, struct rte_mbuf *mbuf)
{
- struct ipv4_hdr *ip = (struct ipv4_hdr*)(beg + ip_offset);
- struct ether_hdr *peth_out;
+ prox_rte_ipv4_hdr *ip = (prox_rte_ipv4_hdr*)(beg + ip_offset);
+ prox_rte_ether_hdr *peth_out;
uint8_t tx_port;
uint32_t dst_ip;
@@ -218,7 +218,7 @@ static uint8_t route_ipv4(struct task_routing *task, uint8_t *beg, uint32_t ip_o
switch(ip->next_proto_id) {
case IPPROTO_GRE: {
struct gre_hdr *pgre = (struct gre_hdr *)(ip + 1);
- dst_ip = ((struct ipv4_hdr *)(pgre + 1))->dst_addr;
+ dst_ip = ((prox_rte_ipv4_hdr *)(pgre + 1))->dst_addr;
break;
}
case IPPROTO_TCP:
@@ -260,7 +260,7 @@ static uint8_t route_ipv4(struct task_routing *task, uint8_t *beg, uint32_t ip_o
static inline uint8_t handle_routing(struct task_routing *task, struct rte_mbuf *mbuf)
{
struct qinq_hdr *qinq;
- struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
switch (peth->ether_type) {
case ETYPE_8021ad: {
@@ -277,7 +277,7 @@ static inline uint8_t handle_routing(struct task_routing *task, struct rte_mbuf
case ETYPE_MPLSU: {
/* skip MPLS headers if any for routing */
struct mpls_hdr *mpls = (struct mpls_hdr *)(peth + 1);
- uint32_t count = sizeof(struct ether_hdr);
+ uint32_t count = sizeof(prox_rte_ether_hdr);
while (!(mpls->bytes & 0x00010000)) {
mpls++;
count += sizeof(struct mpls_hdr);
diff --git a/VNFs/DPPD-PROX/handle_swap.c b/VNFs/DPPD-PROX/handle_swap.c
index 39131013..457c2fac 100644
--- a/VNFs/DPPD-PROX/handle_swap.c
+++ b/VNFs/DPPD-PROX/handle_swap.c
@@ -28,6 +28,7 @@
#include "prefetch.h"
#include "igmp.h"
#include "prox_cksum.h"
+#include "prox_compat.h"
struct task_swap {
struct task_base base;
@@ -45,56 +46,55 @@ struct task_swap {
static void write_src_and_dst_mac(struct task_swap *task, struct rte_mbuf *mbuf)
{
- struct ether_hdr *hdr;
- struct ether_addr mac;
+ prox_rte_ether_hdr *hdr;
+ prox_rte_ether_addr mac;
if (unlikely((task->runtime_flags & (TASK_ARG_DST_MAC_SET|TASK_ARG_SRC_MAC_SET)) == (TASK_ARG_DST_MAC_SET|TASK_ARG_SRC_MAC_SET))) {
/* Source and Destination mac hardcoded */
- hdr = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ hdr = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
rte_memcpy(hdr, task->src_dst_mac, sizeof(task->src_dst_mac));
} else {
- hdr = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ hdr = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
if (likely((task->runtime_flags & TASK_ARG_SRC_MAC_SET) == 0)) {
/* dst mac will be used as src mac */
- ether_addr_copy(&hdr->d_addr, &mac);
+ prox_rte_ether_addr_copy(&hdr->d_addr, &mac);
}
if (unlikely(task->runtime_flags & TASK_ARG_DST_MAC_SET))
- ether_addr_copy((struct ether_addr *)&task->src_dst_mac[0], &hdr->d_addr);
+ prox_rte_ether_addr_copy((prox_rte_ether_addr *)&task->src_dst_mac[0], &hdr->d_addr);
else
- ether_addr_copy(&hdr->s_addr, &hdr->d_addr);
+ prox_rte_ether_addr_copy(&hdr->s_addr, &hdr->d_addr);
if (unlikely(task->runtime_flags & TASK_ARG_SRC_MAC_SET)) {
- ether_addr_copy((struct ether_addr *)&task->src_dst_mac[6], &hdr->s_addr);
+ prox_rte_ether_addr_copy((prox_rte_ether_addr *)&task->src_dst_mac[6], &hdr->s_addr);
} else {
- ether_addr_copy(&mac, &hdr->s_addr);
+ prox_rte_ether_addr_copy(&mac, &hdr->s_addr);
}
}
}
-
-static inline void build_mcast_mac(uint32_t ip, struct ether_addr *dst_mac)
+static inline void build_mcast_mac(uint32_t ip, prox_rte_ether_addr *dst_mac)
{
// MAC address is 01:00:5e followed by 23 LSB of IP address
uint64_t mac = 0x0000005e0001L | ((ip & 0xFFFF7F00L) << 16);
- memcpy(dst_mac, &mac, sizeof(struct ether_addr));
+ memcpy(dst_mac, &mac, sizeof(prox_rte_ether_addr));
}
static inline void build_igmp_message(struct task_base *tbase, struct rte_mbuf *mbuf, uint32_t ip, uint8_t igmp_message)
{
struct task_swap *task = (struct task_swap *)tbase;
- struct ether_hdr *hdr = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
- struct ether_addr dst_mac;
+ prox_rte_ether_hdr *hdr = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
+ prox_rte_ether_addr dst_mac;
build_mcast_mac(ip, &dst_mac);
rte_pktmbuf_pkt_len(mbuf) = 46;
rte_pktmbuf_data_len(mbuf) = 46;
init_mbuf_seg(mbuf);
- ether_addr_copy(&dst_mac, &hdr->d_addr);
- ether_addr_copy((struct ether_addr *)&task->src_dst_mac[6], &hdr->s_addr);
+ prox_rte_ether_addr_copy(&dst_mac, &hdr->d_addr);
+ prox_rte_ether_addr_copy((prox_rte_ether_addr *)&task->src_dst_mac[6], &hdr->s_addr);
hdr->ether_type = ETYPE_IPv4;
- struct ipv4_hdr *ip_hdr = (struct ipv4_hdr *)(hdr + 1);
+ prox_rte_ipv4_hdr *ip_hdr = (prox_rte_ipv4_hdr *)(hdr + 1);
ip_hdr->version_ihl = 0x45; /**< version and header length */
ip_hdr->type_of_service = 0; /**< type of service */
ip_hdr->total_length = rte_cpu_to_be_16(32); /**< length of packet */
@@ -110,25 +110,25 @@ static inline void build_igmp_message(struct task_base *tbase, struct rte_mbuf *
pigmp->max_resp_time = 0;
pigmp->checksum = 0;
pigmp->group_address = ip;
- prox_ip_udp_cksum(mbuf, ip_hdr, sizeof(struct ether_hdr), sizeof(struct ipv4_hdr), task->offload_crc);
+ prox_ip_udp_cksum(mbuf, ip_hdr, sizeof(prox_rte_ether_hdr), sizeof(prox_rte_ipv4_hdr), task->offload_crc);
}
static int handle_swap_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
{
struct task_swap *task = (struct task_swap *)tbase;
- struct ether_hdr *hdr;
- struct ether_addr mac;
- struct ipv4_hdr *ip_hdr;
- struct udp_hdr *udp_hdr;
+ prox_rte_ether_hdr *hdr;
+ prox_rte_ether_addr mac;
+ prox_rte_ipv4_hdr *ip_hdr;
+ prox_rte_udp_hdr *udp_hdr;
struct gre_hdr *pgre;
- struct ipv4_hdr *inner_ip_hdr;
+ prox_rte_ipv4_hdr *inner_ip_hdr;
uint32_t ip;
uint16_t port;
uint8_t out[64] = {0};
struct mpls_hdr *mpls;
uint32_t mpls_len = 0;
struct qinq_hdr *qinq;
- struct vlan_hdr *vlan;
+ prox_rte_vlan_hdr *vlan;
uint16_t j;
struct igmpv2_hdr *pigmp;
uint8_t type;
@@ -142,7 +142,7 @@ static int handle_swap_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, ui
// TODO 1: check packet is long enough for Ethernet + IP + UDP = 42 bytes
for (uint16_t j = 0; j < n_pkts; ++j) {
- hdr = rte_pktmbuf_mtod(mbufs[j], struct ether_hdr *);
+ hdr = rte_pktmbuf_mtod(mbufs[j], prox_rte_ether_hdr *);
switch (hdr->ether_type) {
case ETYPE_MPLSU:
mpls = (struct mpls_hdr *)(hdr + 1);
@@ -152,7 +152,7 @@ static int handle_swap_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, ui
mpls_len += sizeof(struct mpls_hdr);
}
mpls_len += sizeof(struct mpls_hdr);
- ip_hdr = (struct ipv4_hdr *)(mpls + 1);
+ ip_hdr = (prox_rte_ipv4_hdr *)(mpls + 1);
break;
case ETYPE_8021ad:
qinq = (struct qinq_hdr *)hdr;
@@ -161,16 +161,16 @@ static int handle_swap_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, ui
out[j] = OUT_DISCARD;
continue;
}
- ip_hdr = (struct ipv4_hdr *)(qinq + 1);
+ ip_hdr = (prox_rte_ipv4_hdr *)(qinq + 1);
break;
case ETYPE_VLAN:
- vlan = (struct vlan_hdr *)(hdr + 1);
+ vlan = (prox_rte_vlan_hdr *)(hdr + 1);
if (vlan->eth_proto == ETYPE_IPv4) {
- ip_hdr = (struct ipv4_hdr *)(vlan + 1);
+ ip_hdr = (prox_rte_ipv4_hdr *)(vlan + 1);
} else if (vlan->eth_proto == ETYPE_VLAN) {
- vlan = (struct vlan_hdr *)(vlan + 1);
+ vlan = (prox_rte_vlan_hdr *)(vlan + 1);
if (vlan->eth_proto == ETYPE_IPv4) {
- ip_hdr = (struct ipv4_hdr *)(vlan + 1);
+ ip_hdr = (prox_rte_ipv4_hdr *)(vlan + 1);
}
else if (vlan->eth_proto == ETYPE_IPv6) {
plog_warn("Unsupported IPv6\n");
@@ -189,7 +189,7 @@ static int handle_swap_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, ui
}
break;
case ETYPE_IPv4:
- ip_hdr = (struct ipv4_hdr *)(hdr + 1);
+ ip_hdr = (prox_rte_ipv4_hdr *)(hdr + 1);
break;
case ETYPE_IPv6:
plog_warn("Unsupported IPv6\n");
@@ -212,12 +212,12 @@ static int handle_swap_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, ui
ip_hdr->src_addr = ip;
pgre = (struct gre_hdr *)(ip_hdr + 1);
- inner_ip_hdr = ((struct ipv4_hdr *)(pgre + 1));
+ inner_ip_hdr = ((prox_rte_ipv4_hdr *)(pgre + 1));
ip = inner_ip_hdr->dst_addr;
inner_ip_hdr->dst_addr = inner_ip_hdr->src_addr;
inner_ip_hdr->src_addr = ip;
- udp_hdr = (struct udp_hdr *)(inner_ip_hdr + 1);
+ udp_hdr = (prox_rte_udp_hdr *)(inner_ip_hdr + 1);
// TODO 3.1 : verify proto is UPD or TCP
port = udp_hdr->dst_port;
udp_hdr->dst_port = udp_hdr->src_port;
@@ -226,11 +226,11 @@ static int handle_swap_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, ui
break;
case IPPROTO_UDP:
case IPPROTO_TCP:
- if (task->igmp_address && IS_IPV4_MCAST(rte_be_to_cpu_32(ip))) {
+ if (task->igmp_address && PROX_RTE_IS_IPV4_MCAST(rte_be_to_cpu_32(ip))) {
out[j] = OUT_DISCARD;
continue;
}
- udp_hdr = (struct udp_hdr *)(ip_hdr + 1);
+ udp_hdr = (prox_rte_udp_hdr *)(ip_hdr + 1);
ip_hdr->dst_addr = ip_hdr->src_addr;
ip_hdr->src_addr = ip;
@@ -311,7 +311,7 @@ void igmp_leave_group(struct task_base *tbase)
static void init_task_swap(struct task_base *tbase, struct task_args *targ)
{
struct task_swap *task = (struct task_swap *)tbase;
- struct ether_addr *src_addr, *dst_addr;
+ prox_rte_ether_addr *src_addr, *dst_addr;
/*
* The destination MAC of the outgoing packet is based on the config file:
diff --git a/VNFs/DPPD-PROX/handle_untag.c b/VNFs/DPPD-PROX/handle_untag.c
index 2fc8fe64..ba3c6251 100644
--- a/VNFs/DPPD-PROX/handle_untag.c
+++ b/VNFs/DPPD-PROX/handle_untag.c
@@ -65,16 +65,16 @@ static int handle_untag_bulk(struct task_base *tbase, struct rte_mbuf **mbufs, u
return task->base.tx_pkt(&task->base, mbufs, n_pkts, out);
}
-static inline uint8_t untag_mpls(struct rte_mbuf *mbuf, struct ether_hdr *peth)
+static inline uint8_t untag_mpls(struct rte_mbuf *mbuf, prox_rte_ether_hdr *peth)
{
- struct ether_hdr *pneweth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, 4);
+ prox_rte_ether_hdr *pneweth = (prox_rte_ether_hdr *)rte_pktmbuf_adj(mbuf, 4);
const struct mpls_hdr *mpls = (const struct mpls_hdr *)(peth + 1);
- const struct ipv4_hdr *pip = (const struct ipv4_hdr *)(mpls + 1);
+ const prox_rte_ipv4_hdr *pip = (const prox_rte_ipv4_hdr *)(mpls + 1);
PROX_ASSERT(pneweth);
if (mpls->bos == 0) {
// Double MPLS tag
- pneweth = (struct ether_hdr *)rte_pktmbuf_adj(mbuf, 4);
+ pneweth = (prox_rte_ether_hdr *)rte_pktmbuf_adj(mbuf, 4);
PROX_ASSERT(pneweth);
}
@@ -98,13 +98,13 @@ static uint8_t untag_qinq(struct rte_mbuf *mbuf, struct qinq_hdr *qinq)
return OUT_DISCARD;
}
- rte_pktmbuf_adj(mbuf, sizeof(struct qinq_hdr) - sizeof(struct ether_hdr));
+ rte_pktmbuf_adj(mbuf, sizeof(struct qinq_hdr) - sizeof(prox_rte_ether_hdr));
return 0;
}
static inline uint8_t handle_untag(struct task_untag *task, struct rte_mbuf *mbuf)
{
- struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
const uint16_t etype = peth->ether_type;
if (etype != task->etype) {
diff --git a/VNFs/DPPD-PROX/hash_entry_types.h b/VNFs/DPPD-PROX/hash_entry_types.h
index e2cbcb3c..6288d5a9 100644
--- a/VNFs/DPPD-PROX/hash_entry_types.h
+++ b/VNFs/DPPD-PROX/hash_entry_types.h
@@ -18,9 +18,10 @@
#define _HASH_ENTRY_TYPES_H_
#include <rte_ether.h>
+#include "prox_compat.h"
struct ether_addr_port {
- struct ether_addr mac;
+ prox_rte_ether_addr mac;
uint8_t pad;
uint8_t out_idx;
};
diff --git a/VNFs/DPPD-PROX/log.c b/VNFs/DPPD-PROX/log.c
index 56338f89..2094c185 100644
--- a/VNFs/DPPD-PROX/log.c
+++ b/VNFs/DPPD-PROX/log.c
@@ -81,6 +81,13 @@ void plog_init(const char *log_name, int log_name_pid)
tsc_off = rte_rdtsc() + 2500000000;
}
+void plog_end(void)
+{
+ if (fp)
+ fclose(fp);
+ fp = NULL;
+}
+
int plog_set_lvl(int lvl)
{
if (lvl <= PROX_MAX_LOG_LVL) {
@@ -144,8 +151,8 @@ static const char* lvl_to_str(int lvl, int always)
static int dump_pkt(char *dst, size_t dst_size, const struct rte_mbuf *mbuf)
{
- const struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, const struct ether_hdr *);
- const struct ipv4_hdr *dpip = (const struct ipv4_hdr *)(peth + 1);
+ const prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbuf, const prox_rte_ether_hdr *);
+ const prox_rte_ipv4_hdr *dpip = (const prox_rte_ipv4_hdr *)(peth + 1);
const uint8_t *pkt_bytes = (const uint8_t *)peth;
const uint16_t len = rte_pktmbuf_pkt_len(mbuf);
size_t str_len = 0;
diff --git a/VNFs/DPPD-PROX/log.h b/VNFs/DPPD-PROX/log.h
index a5dcf47a..0d2fba18 100644
--- a/VNFs/DPPD-PROX/log.h
+++ b/VNFs/DPPD-PROX/log.h
@@ -81,6 +81,7 @@ __attribute__((format(printf, 2, 3))) static inline int plogdx_dbg(__attribute__
#endif
void plog_init(const char *log_name, int log_name_pid);
+void plog_end(void);
void file_print(const char *str);
int plog_set_lvl(int lvl);
diff --git a/VNFs/DPPD-PROX/main.c b/VNFs/DPPD-PROX/main.c
index e4663fee..d87561d0 100644
--- a/VNFs/DPPD-PROX/main.c
+++ b/VNFs/DPPD-PROX/main.c
@@ -322,7 +322,7 @@ static void configure_if_rx_queues(struct task_args *targ, uint8_t socket)
// If the mbuf size (of the rx task) is not big enough, we might receive multiple segments
// This is usually the case when setting a big mtu size i.e. enabling jumbo frames.
// If the packets get transmitted, then multi segments will have to be enabled on the TX port
- uint16_t max_frame_size = port->mtu + ETHER_HDR_LEN + ETHER_CRC_LEN + 2 * PROX_VLAN_TAG_SIZE;
+ uint16_t max_frame_size = port->mtu + PROX_RTE_ETHER_HDR_LEN + PROX_RTE_ETHER_CRC_LEN + 2 * PROX_VLAN_TAG_SIZE;
if (max_frame_size + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM > targ->mbuf_size) {
targ->task_init->flag_features |= TASK_FEATURE_TXQ_FLAGS_MULTSEGS;
}
@@ -686,8 +686,8 @@ static void set_mbuf_size(struct task_args *targ)
continue;
}
port = &prox_port_cfg[if_port];
- if (max_frame_size < port->mtu + ETHER_HDR_LEN + ETHER_CRC_LEN + 2 * PROX_VLAN_TAG_SIZE)
- max_frame_size = port->mtu + ETHER_HDR_LEN + ETHER_CRC_LEN + 2 * PROX_VLAN_TAG_SIZE;
+ if (max_frame_size < port->mtu + PROX_RTE_ETHER_HDR_LEN + PROX_RTE_ETHER_CRC_LEN + 2 * PROX_VLAN_TAG_SIZE)
+ max_frame_size = port->mtu + PROX_RTE_ETHER_HDR_LEN + PROX_RTE_ETHER_CRC_LEN + 2 * PROX_VLAN_TAG_SIZE;
if (min_buffer_size < port->min_rx_bufsize)
min_buffer_size = port->min_rx_bufsize;
diff --git a/VNFs/DPPD-PROX/mbuf_utils.h b/VNFs/DPPD-PROX/mbuf_utils.h
index 22d57a39..d48b5098 100644
--- a/VNFs/DPPD-PROX/mbuf_utils.h
+++ b/VNFs/DPPD-PROX/mbuf_utils.h
@@ -22,6 +22,7 @@
#include <rte_ip.h>
#include <rte_version.h>
#include <rte_ether.h>
+#include "prox_compat.h"
static void init_mbuf_seg(struct rte_mbuf *mbuf)
{
@@ -35,7 +36,7 @@ static void init_mbuf_seg(struct rte_mbuf *mbuf)
static uint16_t pkt_len_to_wire_size(uint16_t pkt_len)
{
- return (pkt_len < 60? 60 : pkt_len) + ETHER_CRC_LEN + 20;
+ return (pkt_len < 60? 60 : pkt_len) + PROX_RTE_ETHER_CRC_LEN + 20;
}
static uint16_t mbuf_wire_size(const struct rte_mbuf *mbuf)
@@ -45,7 +46,7 @@ static uint16_t mbuf_wire_size(const struct rte_mbuf *mbuf)
return pkt_len_to_wire_size(pkt_len);
}
-static uint16_t mbuf_calc_padlen(const struct rte_mbuf *mbuf, void *pkt, struct ipv4_hdr *ipv4)
+static uint16_t mbuf_calc_padlen(const struct rte_mbuf *mbuf, void *pkt, prox_rte_ipv4_hdr *ipv4)
{
uint16_t pkt_len = rte_pktmbuf_pkt_len(mbuf);
uint16_t ip_offset = (uint8_t *)ipv4 - (uint8_t*)pkt;
diff --git a/VNFs/DPPD-PROX/packet_utils.c b/VNFs/DPPD-PROX/packet_utils.c
index 4ab7c9c9..43350134 100644
--- a/VNFs/DPPD-PROX/packet_utils.c
+++ b/VNFs/DPPD-PROX/packet_utils.c
@@ -26,15 +26,15 @@
static inline int find_ip(struct ether_hdr_arp *pkt, uint16_t len, uint32_t *ip_dst)
{
- struct vlan_hdr *vlan_hdr;
- struct ether_hdr *eth_hdr = (struct ether_hdr*)pkt;
- struct ipv4_hdr *ip;
+ prox_rte_vlan_hdr *vlan_hdr;
+ prox_rte_ether_hdr *eth_hdr = (prox_rte_ether_hdr*)pkt;
+ prox_rte_ipv4_hdr *ip;
uint16_t ether_type = eth_hdr->ether_type;
- uint16_t l2_len = sizeof(struct ether_hdr);
+ uint16_t l2_len = sizeof(prox_rte_ether_hdr);
// Unstack VLAN tags
- while (((ether_type == ETYPE_8021ad) || (ether_type == ETYPE_VLAN)) && (l2_len + sizeof(struct vlan_hdr) < len)) {
- vlan_hdr = (struct vlan_hdr *)((uint8_t *)pkt + l2_len);
+ while (((ether_type == ETYPE_8021ad) || (ether_type == ETYPE_VLAN)) && (l2_len + sizeof(prox_rte_vlan_hdr) < len)) {
+ vlan_hdr = (prox_rte_vlan_hdr *)((uint8_t *)pkt + l2_len);
l2_len +=4;
ether_type = vlan_hdr->eth_proto;
}
@@ -58,8 +58,8 @@ static inline int find_ip(struct ether_hdr_arp *pkt, uint16_t len, uint32_t *ip_
break;
}
- if (l2_len && (l2_len + sizeof(struct ipv4_hdr) <= len)) {
- struct ipv4_hdr *ip = (struct ipv4_hdr *)((uint8_t *)pkt + l2_len);
+ if (l2_len && (l2_len + sizeof(prox_rte_ipv4_hdr) <= len)) {
+ prox_rte_ipv4_hdr *ip = (prox_rte_ipv4_hdr *)((uint8_t *)pkt + l2_len);
// TODO: implement LPM => replace ip_dst by next hop IP DST
*ip_dst = ip->dst_addr;
return 0;
@@ -79,13 +79,13 @@ int write_dst_mac(struct task_base *tbase, struct rte_mbuf *mbuf, uint32_t *ip_d
{
const uint64_t hz = rte_get_tsc_hz();
struct ether_hdr_arp *packet = rte_pktmbuf_mtod(mbuf, struct ether_hdr_arp *);
- struct ether_addr *mac = &packet->ether_hdr.d_addr;
+ prox_rte_ether_addr *mac = &packet->ether_hdr.d_addr;
uint64_t tsc = rte_rdtsc();
struct l3_base *l3 = &(tbase->l3);
if (l3->gw.ip) {
if (likely((l3->flags & FLAG_DST_MAC_KNOWN) && (tsc < l3->gw.arp_update_time) && (tsc < l3->gw.arp_timeout))) {
- memcpy(mac, &l3->gw.mac, sizeof(struct ether_addr));
+ memcpy(mac, &l3->gw.mac, sizeof(prox_rte_ether_addr));
return SEND_MBUF;
} else if (tsc > l3->gw.arp_update_time) {
// long time since we have sent an arp, send arp
@@ -93,7 +93,7 @@ int write_dst_mac(struct task_base *tbase, struct rte_mbuf *mbuf, uint32_t *ip_d
*ip_dst = l3->gw.ip;
if ((l3->flags & FLAG_DST_MAC_KNOWN) && (tsc < l3->gw.arp_timeout)){
// MAC is valid in the table => send also the mbuf
- memcpy(mac, &l3->gw.mac, sizeof(struct ether_addr));
+ memcpy(mac, &l3->gw.mac, sizeof(prox_rte_ether_addr));
return SEND_MBUF_AND_ARP;
} else {
// MAC still unknown, or timed out => only send ARP
@@ -116,14 +116,14 @@ int write_dst_mac(struct task_base *tbase, struct rte_mbuf *mbuf, uint32_t *ip_d
// IP address already in table
if ((tsc < l3->optimized_arp_table[idx].arp_update_time) && (tsc < l3->optimized_arp_table[idx].arp_timeout)) {
// MAC address was recently updated in table, use it
- memcpy(mac, &l3->optimized_arp_table[idx].mac, sizeof(struct ether_addr));
+ memcpy(mac, &l3->optimized_arp_table[idx].mac, sizeof(prox_rte_ether_addr));
return SEND_MBUF;
} else if (tsc > l3->optimized_arp_table[idx].arp_update_time) {
// ARP not sent since a long time, send ARP
l3->optimized_arp_table[idx].arp_update_time = tsc + l3->arp_update_time * hz / 1000;
if (tsc < l3->optimized_arp_table[idx].arp_timeout) {
// MAC still valid => also send mbuf
- memcpy(mac, &l3->optimized_arp_table[idx].mac, sizeof(struct ether_addr));
+ memcpy(mac, &l3->optimized_arp_table[idx].mac, sizeof(prox_rte_ether_addr));
return SEND_MBUF_AND_ARP;
} else {
// MAC unvalid => only send ARP
@@ -178,14 +178,14 @@ int write_dst_mac(struct task_base *tbase, struct rte_mbuf *mbuf, uint32_t *ip_d
// IP has been found
if (likely((tsc < l3->arp_table[ret].arp_update_time) && (tsc < l3->arp_table[ret].arp_timeout))) {
// MAC still valid and ARP sent recently
- memcpy(mac, &l3->arp_table[ret].mac, sizeof(struct ether_addr));
+ memcpy(mac, &l3->arp_table[ret].mac, sizeof(prox_rte_ether_addr));
return SEND_MBUF;
} else if (tsc > l3->arp_table[ret].arp_update_time) {
// ARP not sent since a long time, send ARP
l3->arp_table[ret].arp_update_time = tsc + l3->arp_update_time * hz / 1000;
if (tsc < l3->arp_table[ret].arp_timeout) {
// MAC still valid => send also MBUF
- memcpy(mac, &l3->arp_table[ret].mac, sizeof(struct ether_addr));
+ memcpy(mac, &l3->arp_table[ret].mac, sizeof(prox_rte_ether_addr));
return SEND_MBUF_AND_ARP;
} else {
return SEND_ARP;
@@ -317,7 +317,7 @@ void handle_ctrl_plane_pkts(struct task_base *tbase, struct rte_mbuf **mbufs, ui
}
if (idx < l3->n_pkts) {
// IP not found; this is a reply while we never asked for the request!
- memcpy(&l3->optimized_arp_table[idx].mac, &(hdr->arp.data.sha), sizeof(struct ether_addr));
+ memcpy(&l3->optimized_arp_table[idx].mac, &(hdr->arp.data.sha), sizeof(prox_rte_ether_addr));
l3->optimized_arp_table[idx].arp_timeout = tsc + l3->arp_timeout * hz / 1000;
}
} else {
@@ -325,7 +325,7 @@ void handle_ctrl_plane_pkts(struct task_base *tbase, struct rte_mbuf **mbufs, ui
if (ret < 0) {
plogx_info("Unable add ip %d.%d.%d.%d in mac_hash\n", IP4(ip));
} else {
- memcpy(&l3->arp_table[ret].mac, &(hdr->arp.data.sha), sizeof(struct ether_addr));
+ memcpy(&l3->arp_table[ret].mac, &(hdr->arp.data.sha), sizeof(prox_rte_ether_addr));
l3->arp_table[ret].arp_timeout = tsc + l3->arp_timeout * hz / 1000;
}
}
diff --git a/VNFs/DPPD-PROX/packet_utils.h b/VNFs/DPPD-PROX/packet_utils.h
index cb4dc913..d6e2dbb9 100644
--- a/VNFs/DPPD-PROX/packet_utils.h
+++ b/VNFs/DPPD-PROX/packet_utils.h
@@ -16,6 +16,7 @@
#ifndef _PACKET_UTILS_H_
#define _PACKET_UTILS_H_
+#include "prox_compat.h"
#include "arp.h"
#include "quit.h"
#include "prox_malloc.h"
@@ -42,7 +43,7 @@ struct arp_table {
uint64_t arp_update_time;
uint64_t arp_timeout;
uint32_t ip;
- struct ether_addr mac;
+ prox_rte_ether_addr mac;
};
struct l3_base {
struct rte_ring *ctrl_plane_ring;
diff --git a/VNFs/DPPD-PROX/parse_utils.c b/VNFs/DPPD-PROX/parse_utils.c
index 786c2141..887de803 100644
--- a/VNFs/DPPD-PROX/parse_utils.c
+++ b/VNFs/DPPD-PROX/parse_utils.c
@@ -422,7 +422,7 @@ int parse_ip6(struct ipv6_addr *addr, const char *str2)
return 0;
}
-int parse_mac(struct ether_addr *ether_addr, const char *str2)
+int parse_mac(prox_rte_ether_addr *ether_addr, const char *str2)
{
char str[MAX_STR_LEN_PROC];
char *addr_parts[7];
diff --git a/VNFs/DPPD-PROX/parse_utils.h b/VNFs/DPPD-PROX/parse_utils.h
index 6e4bc770..32c95f4e 100644
--- a/VNFs/DPPD-PROX/parse_utils.h
+++ b/VNFs/DPPD-PROX/parse_utils.h
@@ -18,12 +18,12 @@
#define _PARSE_UTILS_H_
#include <inttypes.h>
+#include "prox_compat.h"
#include "ip_subnet.h"
#define MAX_STR_LEN_PROC (3 * MAX_PKT_SIZE + 20)
struct ipv6_addr;
-struct ether_addr;
enum ctrl_type {CTRL_TYPE_DP, CTRL_TYPE_MSG, CTRL_TYPE_PKT};
@@ -53,7 +53,7 @@ int parse_ip(uint32_t *paddr, const char *saddr);
int parse_ip6(struct ipv6_addr *addr, const char *saddr);
-int parse_mac(struct ether_addr *paddr, const char *saddr);
+int parse_mac(prox_rte_ether_addr *paddr, const char *saddr);
/* return error on overflow or invalid suffix*/
int parse_kmg(uint32_t* val, const char *str);
diff --git a/VNFs/DPPD-PROX/pkt_parser.h b/VNFs/DPPD-PROX/pkt_parser.h
index 285d42f9..746830bf 100644
--- a/VNFs/DPPD-PROX/pkt_parser.h
+++ b/VNFs/DPPD-PROX/pkt_parser.h
@@ -24,6 +24,7 @@
#include <rte_tcp.h>
#include <rte_byteorder.h>
+#include "prox_compat.h"
#include "log.h"
#include "etypes.h"
@@ -69,28 +70,28 @@ static void pkt_tuple_debug(const struct pkt_tuple *pt)
/* Return 0 on success, i.e. packets parsed without any error. */
static int parse_pkt(struct rte_mbuf *mbuf, struct pkt_tuple *pt, struct l4_meta *l4_meta)
{
- struct ether_hdr *peth = rte_pktmbuf_mtod(mbuf, struct ether_hdr *);
+ prox_rte_ether_hdr *peth = rte_pktmbuf_mtod(mbuf, prox_rte_ether_hdr *);
size_t l2_types_count = 0;
- struct ipv4_hdr* pip = 0;
+ prox_rte_ipv4_hdr* pip = 0;
/* L2 */
pt->l2_types[l2_types_count++] = peth->ether_type;
switch (peth->ether_type) {
case ETYPE_IPv4:
- pip = (struct ipv4_hdr *)(peth + 1);
+ pip = (prox_rte_ipv4_hdr *)(peth + 1);
break;
case ETYPE_VLAN: {
- struct vlan_hdr *vlan = (struct vlan_hdr *)(peth + 1);
+ prox_rte_vlan_hdr *vlan = (prox_rte_vlan_hdr *)(peth + 1);
pt->l2_types[l2_types_count++] = vlan->eth_proto;
if (vlan->eth_proto == ETYPE_IPv4) {
- pip = (struct ipv4_hdr *)(peth + 1);
+ pip = (prox_rte_ipv4_hdr *)(peth + 1);
}
else if (vlan->eth_proto == ETYPE_VLAN) {
- struct vlan_hdr *vlan = (struct vlan_hdr *)(peth + 1);
+ prox_rte_vlan_hdr *vlan = (prox_rte_vlan_hdr *)(peth + 1);
pt->l2_types[l2_types_count++] = vlan->eth_proto;
if (vlan->eth_proto == ETYPE_IPv4) {
- pip = (struct ipv4_hdr *)(peth + 1);
+ pip = (prox_rte_ipv4_hdr *)(peth + 1);
}
else if (vlan->eth_proto == ETYPE_IPv6) {
return 1;
@@ -103,13 +104,13 @@ static int parse_pkt(struct rte_mbuf *mbuf, struct pkt_tuple *pt, struct l4_meta
}
break;
case ETYPE_8021ad: {
- struct vlan_hdr *vlan = (struct vlan_hdr *)(peth + 1);
+ prox_rte_vlan_hdr *vlan = (prox_rte_vlan_hdr *)(peth + 1);
pt->l2_types[l2_types_count++] = vlan->eth_proto;
if (vlan->eth_proto == ETYPE_VLAN) {
- struct vlan_hdr *vlan = (struct vlan_hdr *)(peth + 1);
+ prox_rte_vlan_hdr *vlan = (prox_rte_vlan_hdr *)(peth + 1);
pt->l2_types[l2_types_count++] = vlan->eth_proto;
if (vlan->eth_proto == ETYPE_IPv4) {
- pip = (struct ipv4_hdr *)(peth + 1);
+ pip = (prox_rte_ipv4_hdr *)(peth + 1);
}
else {
return 1;
@@ -148,21 +149,21 @@ static int parse_pkt(struct rte_mbuf *mbuf, struct pkt_tuple *pt, struct l4_meta
/* L4 parser */
if (pt->proto_id == IPPROTO_UDP) {
- struct udp_hdr *udp = (struct udp_hdr*)(pip + 1);
+ prox_rte_udp_hdr *udp = (prox_rte_udp_hdr*)(pip + 1);
l4_meta->l4_hdr = (uint8_t*)udp;
pt->src_port = udp->src_port;
pt->dst_port = udp->dst_port;
- l4_meta->payload = ((uint8_t*)udp) + sizeof(struct udp_hdr);
- l4_meta->len = rte_be_to_cpu_16(udp->dgram_len) - sizeof(struct udp_hdr);
+ l4_meta->payload = ((uint8_t*)udp) + sizeof(prox_rte_udp_hdr);
+ l4_meta->len = rte_be_to_cpu_16(udp->dgram_len) - sizeof(prox_rte_udp_hdr);
}
else if (pt->proto_id == IPPROTO_TCP) {
- struct tcp_hdr *tcp = (struct tcp_hdr*)(pip + 1);
+ prox_rte_tcp_hdr *tcp = (prox_rte_tcp_hdr*)(pip + 1);
l4_meta->l4_hdr = (uint8_t*)tcp;
pt->src_port = tcp->src_port;
pt->dst_port = tcp->dst_port;
l4_meta->payload = ((uint8_t*)tcp) + ((tcp->data_off >> 4)*4);
- l4_meta->len = rte_be_to_cpu_16(pip->total_length) - sizeof(struct ipv4_hdr) - ((tcp->data_off >> 4)*4);
+ l4_meta->len = rte_be_to_cpu_16(pip->total_length) - sizeof(prox_rte_ipv4_hdr) - ((tcp->data_off >> 4)*4);
}
else {
plog_err("unsupported protocol %d\n", pt->proto_id);
diff --git a/VNFs/DPPD-PROX/pkt_prototypes.h b/VNFs/DPPD-PROX/pkt_prototypes.h
index 5d55bacb..9acde34a 100644
--- a/VNFs/DPPD-PROX/pkt_prototypes.h
+++ b/VNFs/DPPD-PROX/pkt_prototypes.h
@@ -31,7 +31,7 @@ static const struct gre_hdr gre_hdr_proto = {
.bits = GRE_KEY_PRESENT
};
-static const struct ipv4_hdr tunnel_ip_proto = {
+static const prox_rte_ipv4_hdr tunnel_ip_proto = {
.version_ihl = 0x45,
.type_of_service = 0,
.packet_id = 0,
diff --git a/VNFs/DPPD-PROX/prox_args.c b/VNFs/DPPD-PROX/prox_args.c
index a5d10a60..d31fac29 100644
--- a/VNFs/DPPD-PROX/prox_args.c
+++ b/VNFs/DPPD-PROX/prox_args.c
@@ -610,8 +610,8 @@ static int get_port_cfg(unsigned sindex, char *str, void *data)
// A frame of 1526 bytes (1500 bytes mtu, 14 bytes hdr, 4 bytes crc and 8 bytes vlan)
// should not be considered as a jumbo frame. However rte_ethdev.c considers that
// the max_rx_pkt_len for a non jumbo frame is 1518
- cfg->port_conf.rxmode.max_rx_pkt_len = cfg->mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
- if (cfg->port_conf.rxmode.max_rx_pkt_len > ETHER_MAX_LEN) {
+ cfg->port_conf.rxmode.max_rx_pkt_len = cfg->mtu + PROX_RTE_ETHER_HDR_LEN + PROX_RTE_ETHER_CRC_LEN;
+ if (cfg->port_conf.rxmode.max_rx_pkt_len > PROX_RTE_ETHER_MAX_LEN) {
cfg->requested_rx_offload |= DEV_RX_OFFLOAD_JUMBO_FRAME;
}
}
@@ -1554,6 +1554,10 @@ static int get_core_cfg(unsigned sindex, char *str, void *data)
if (err) {
return -1;
}
+ if (queue_id >= RTE_SCHED_BE_QUEUES_PER_PIPE) {
+ set_errf("queue_id must be < %d", RTE_SCHED_BE_QUEUES_PER_PIPE);
+ return -1;
+ }
targ->qos_conf.pipe_params[0].wrr_weights[queue_id] = val;
return 0;
}
diff --git a/VNFs/DPPD-PROX/prox_cksum.c b/VNFs/DPPD-PROX/prox_cksum.c
index 58e05a6b..11d37a6c 100644
--- a/VNFs/DPPD-PROX/prox_cksum.c
+++ b/VNFs/DPPD-PROX/prox_cksum.c
@@ -21,9 +21,9 @@
/* compute IP 16 bit checksum */
/* The hdr_checksum field must be set to 0 by the caller. */
-inline void prox_ip_cksum_sw(struct ipv4_hdr *buf)
+inline void prox_ip_cksum_sw(prox_rte_ipv4_hdr *buf)
{
- const uint16_t size = sizeof(struct ipv4_hdr);
+ const uint16_t size = sizeof(prox_rte_ipv4_hdr);
uint32_t cksum = 0;
uint32_t nb_dwords;
uint32_t tail, mask;
@@ -73,7 +73,7 @@ static inline uint16_t calc_pseudo_checksum(uint8_t ipproto, uint16_t len, uint3
return csum;
}
-static inline void prox_write_udp_pseudo_hdr(struct udp_hdr *udp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr)
+static inline void prox_write_udp_pseudo_hdr(prox_rte_udp_hdr *udp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr)
{
/* Note that the csum is not complemented, while the pseaudo
header checksum is calculated as "... the 16-bit one's
@@ -84,18 +84,18 @@ static inline void prox_write_udp_pseudo_hdr(struct udp_hdr *udp, uint16_t len,
udp->dgram_cksum = calc_pseudo_checksum(IPPROTO_UDP, len, src_ip_addr, dst_ip_addr);
}
-static inline void prox_write_tcp_pseudo_hdr(struct tcp_hdr *tcp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr)
+static inline void prox_write_tcp_pseudo_hdr(prox_rte_tcp_hdr *tcp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr)
{
tcp->cksum = calc_pseudo_checksum(IPPROTO_TCP, len, src_ip_addr, dst_ip_addr);
}
-inline void prox_ip_udp_cksum(struct rte_mbuf *mbuf, struct ipv4_hdr *pip, uint16_t l2_len, uint16_t l3_len, int cksum_offload)
+inline void prox_ip_udp_cksum(struct rte_mbuf *mbuf, prox_rte_ipv4_hdr *pip, uint16_t l2_len, uint16_t l3_len, int cksum_offload)
{
prox_ip_cksum(mbuf, pip, l2_len, l3_len, cksum_offload & DEV_TX_OFFLOAD_IPV4_CKSUM);
uint32_t l4_len = rte_bswap16(pip->total_length) - l3_len;
if (pip->next_proto_id == IPPROTO_UDP) {
- struct udp_hdr *udp = (struct udp_hdr *)(((uint8_t*)pip) + l3_len);
+ prox_rte_udp_hdr *udp = (prox_rte_udp_hdr *)(((uint8_t*)pip) + l3_len);
#ifndef SOFT_CRC
if (cksum_offload & DEV_TX_OFFLOAD_UDP_CKSUM) {
mbuf->ol_flags |= PKT_TX_UDP_CKSUM;
@@ -104,7 +104,7 @@ inline void prox_ip_udp_cksum(struct rte_mbuf *mbuf, struct ipv4_hdr *pip, uint1
#endif
prox_udp_cksum_sw(udp, l4_len, pip->src_addr, pip->dst_addr);
} else if (pip->next_proto_id == IPPROTO_TCP) {
- struct tcp_hdr *tcp = (struct tcp_hdr *)(((uint8_t*)pip) + l3_len);
+ prox_rte_tcp_hdr *tcp = (prox_rte_tcp_hdr *)(((uint8_t*)pip) + l3_len);
#ifndef SOFT_CRC
if (cksum_offload & DEV_TX_OFFLOAD_TCP_CKSUM) {
prox_write_tcp_pseudo_hdr(tcp, l4_len, pip->src_addr, pip->dst_addr);
@@ -143,14 +143,14 @@ static inline uint16_t checksum_byte_seq(uint16_t *buf, uint16_t len)
return ~csum;
}
-inline void prox_udp_cksum_sw(struct udp_hdr *udp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr)
+inline void prox_udp_cksum_sw(prox_rte_udp_hdr *udp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr)
{
prox_write_udp_pseudo_hdr(udp, len, src_ip_addr, dst_ip_addr);
uint16_t csum = checksum_byte_seq((uint16_t *)udp, len);
udp->dgram_cksum = csum;
}
-inline void prox_tcp_cksum_sw(struct tcp_hdr *tcp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr)
+inline void prox_tcp_cksum_sw(prox_rte_tcp_hdr *tcp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr)
{
prox_write_tcp_pseudo_hdr(tcp, len, src_ip_addr, dst_ip_addr);
diff --git a/VNFs/DPPD-PROX/prox_cksum.h b/VNFs/DPPD-PROX/prox_cksum.h
index 57489900..6ba50268 100644
--- a/VNFs/DPPD-PROX/prox_cksum.h
+++ b/VNFs/DPPD-PROX/prox_cksum.h
@@ -26,6 +26,7 @@
#include <rte_tcp.h>
#include <rte_mbuf.h>
#include "igmp.h"
+#include "prox_compat.h"
#if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
#define CALC_TX_OL(l2_len, l3_len) ((uint64_t)(l2_len) | (uint64_t)(l3_len) << 7)
@@ -43,9 +44,9 @@ static void prox_ip_cksum_hw(struct rte_mbuf *mbuf, uint16_t l2_len, uint16_t l3
mbuf->ol_flags |= PKT_TX_IP_CKSUM;
}
-void prox_ip_cksum_sw(struct ipv4_hdr *buf);
+void prox_ip_cksum_sw(prox_rte_ipv4_hdr *buf);
-static inline void prox_ip_cksum(struct rte_mbuf *mbuf, struct ipv4_hdr *buf, uint16_t l2_len, uint16_t l3_len, int offload)
+static inline void prox_ip_cksum(struct rte_mbuf *mbuf, prox_rte_ipv4_hdr *buf, uint16_t l2_len, uint16_t l3_len, int offload)
{
buf->hdr_checksum = 0;
#ifdef SOFT_CRC
@@ -60,11 +61,11 @@ static inline void prox_ip_cksum(struct rte_mbuf *mbuf, struct ipv4_hdr *buf, ui
#endif
}
-void prox_ip_udp_cksum(struct rte_mbuf *mbuf, struct ipv4_hdr *buf, uint16_t l2_len, uint16_t l3_len, int cksum_offload);
+void prox_ip_udp_cksum(struct rte_mbuf *mbuf, prox_rte_ipv4_hdr *buf, uint16_t l2_len, uint16_t l3_len, int cksum_offload);
/* src_ip_addr/dst_ip_addr are in network byte order */
-void prox_udp_cksum_sw(struct udp_hdr *udp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr);
-void prox_tcp_cksum_sw(struct tcp_hdr *tcp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr);
+void prox_udp_cksum_sw(prox_rte_udp_hdr *udp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr);
+void prox_tcp_cksum_sw(prox_rte_tcp_hdr *tcp, uint16_t len, uint32_t src_ip_addr, uint32_t dst_ip_addr);
void prox_igmp_cksum_sw(struct igmpv2_hdr *igmp, uint16_t len);
#endif /* _PROX_CKSUM_H_ */
diff --git a/VNFs/DPPD-PROX/prox_compat.h b/VNFs/DPPD-PROX/prox_compat.h
index 001caa6d..9c18e36f 100644
--- a/VNFs/DPPD-PROX/prox_compat.h
+++ b/VNFs/DPPD-PROX/prox_compat.h
@@ -13,7 +13,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
*/
-
#ifndef _PROX_COMPAT_H_
#define _PROX_COMPAT_H_
#include <rte_common.h>
@@ -150,6 +149,64 @@ static void *prox_rte_table_create(struct prox_rte_table_params *params, int soc
#define prox_rte_sched_port_pkt_write(A,B,C,D,E,F,G) rte_sched_port_pkt_write(A,B,C,D,E,F,G);
#endif
+#if RTE_VERSION < RTE_VERSION_NUM(19,8,0,0)
+#if RTE_VERSION >= RTE_VERSION_NUM(18,5,0,0)
+typedef struct vxlan_gpe_hdr prox_rte_vxlan_gpe_hdr;
+#endif
+#define PROX_RTE_ETHER_CRC_LEN ETHER_CRC_LEN
+#define PROX_RTE_ETHER_MIN_LEN ETHER_MIN_LEN
+#define PROX_RTE_ETHER_MAX_LEN ETHER_MAX_LEN
+#define PROX_RTE_ETHER_HDR_LEN ETHER_HDR_LEN
+#define PROX_RTE_TCP_SYN_FLAG TCP_SYN_FLAG
+#define PROX_RTE_TCP_FIN_FLAG TCP_FIN_FLAG
+#define PROX_RTE_TCP_RST_FLAG TCP_RST_FLAG
+#define PROX_RTE_TCP_ACK_FLAG TCP_ACK_FLAG
+
+#define prox_rte_ether_addr_copy ether_addr_copy
+#define prox_rte_eth_random_addr eth_random_addr
+
+typedef struct ipv6_hdr prox_rte_ipv6_hdr;
+typedef struct ipv4_hdr prox_rte_ipv4_hdr;
+typedef struct ether_addr prox_rte_ether_addr;
+typedef struct ether_hdr prox_rte_ether_hdr;
+typedef struct vlan_hdr prox_rte_vlan_hdr;
+typedef struct udp_hdr prox_rte_udp_hdr;
+typedef struct tcp_hdr prox_rte_tcp_hdr;
+
+#ifndef RTE_SCHED_BE_QUEUES_PER_PIPE
+#define RTE_SCHED_BE_QUEUES_PER_PIPE RTE_SCHED_QUEUES_PER_PIPE
+#endif
+
+#define PROX_RTE_IS_IPV4_MCAST IS_IPV4_MCAST
+#define prox_rte_is_same_ether_addr is_same_ether_addr
+#else
+
+#define PROX_RTE_ETHER_CRC_LEN RTE_ETHER_CRC_LEN
+#define PROX_RTE_ETHER_MIN_LEN RTE_ETHER_MIN_LEN
+#define PROX_RTE_ETHER_MAX_LEN RTE_ETHER_MAX_LEN
+#define PROX_RTE_ETHER_HDR_LEN RTE_ETHER_HDR_LEN
+#define PROX_RTE_TCP_SYN_FLAG RTE_TCP_SYN_FLAG
+#define PROX_RTE_TCP_FIN_FLAG RTE_TCP_FIN_FLAG
+#define PROX_RTE_TCP_RST_FLAG RTE_TCP_RST_FLAG
+#define PROX_RTE_TCP_ACK_FLAG RTE_TCP_ACK_FLAG
+
+#define prox_rte_ether_addr_copy rte_ether_addr_copy
+#define prox_rte_eth_random_addr rte_eth_random_addr
+
+typedef struct rte_ipv6_hdr prox_rte_ipv6_hdr;
+typedef struct rte_ipv4_hdr prox_rte_ipv4_hdr;
+typedef struct rte_ether_addr prox_rte_ether_addr;
+typedef struct rte_ether_hdr prox_rte_ether_hdr;
+typedef struct rte_vlan_hdr prox_rte_vlan_hdr;
+typedef struct rte_vxlan_gpe_hdr prox_rte_vxlan_gpe_hdr;
+typedef struct rte_udp_hdr prox_rte_udp_hdr;
+typedef struct rte_tcp_hdr prox_rte_tcp_hdr;
+
+#define PROX_RTE_IS_IPV4_MCAST RTE_IS_IPV4_MCAST
+#define prox_rte_is_same_ether_addr rte_is_same_ether_addr
+
+#endif
+
static inline char *prox_strncpy(char * dest, const char * src, size_t count)
{
#pragma GCC diagnostic push
@@ -180,14 +237,19 @@ static int prox_rte_cryptodev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pa
}
#else
-#define prox_esp_hdr esp_hdr
#define prox_rte_cryptodev_qp_conf rte_cryptodev_qp_conf
-
static int prox_rte_cryptodev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id, struct prox_rte_cryptodev_qp_conf *qp_conf, int socket_id)
{
return rte_cryptodev_queue_pair_setup(dev_id, queue_pair_id, (struct rte_cryptodev_qp_conf *)qp_conf, socket_id);
}
+#if RTE_VERSION < RTE_VERSION_NUM(19,8,0,0)
+#define prox_esp_hdr esp_hdr
+
+#else // From DPDK 19.08
+#define prox_esp_hdr rte_esp_hdr
+
+#endif
#endif
#endif // CONFIG_RTE_LIBRTE_PMD_AESNI_MB
diff --git a/VNFs/DPPD-PROX/prox_lua_types.c b/VNFs/DPPD-PROX/prox_lua_types.c
index f901b931..3ef3d472 100644
--- a/VNFs/DPPD-PROX/prox_lua_types.c
+++ b/VNFs/DPPD-PROX/prox_lua_types.c
@@ -183,7 +183,7 @@ int lua_to_ip6(struct lua_State *L, enum lua_place from, const char *name, uint8
return 0;
}
-int lua_to_mac(struct lua_State *L, enum lua_place from, const char *name, struct ether_addr *mac)
+int lua_to_mac(struct lua_State *L, enum lua_place from, const char *name, prox_rte_ether_addr *mac)
{
uint32_t n_entries;
uint32_t mac_array[4];
@@ -419,7 +419,7 @@ int lua_to_next_hop(struct lua_State *L, enum lua_place from, const char *name,
uint32_t port_id;
uint32_t ip;
uint32_t mpls;
- struct ether_addr mac;
+ prox_rte_ether_addr mac;
int pop;
if ((pop = lua_getfrom(L, from, name)) < 0)
@@ -463,7 +463,7 @@ int lua_to_next_hop6(struct lua_State *L, enum lua_place from, const char *name,
{
struct next_hop6 *ret;
uint32_t next_hop_index, port_id, mpls;
- struct ether_addr mac;
+ prox_rte_ether_addr mac;
uint8_t ip[16];
int pop;
@@ -919,7 +919,7 @@ int lua_to_cpe_table_data(struct lua_State *L, enum lua_place from, const char *
struct ip4_subnet cidr;
uint32_t n_entries = 0;
uint32_t port_idx, gre_id, svlan, cvlan, user;
- struct ether_addr mac;
+ prox_rte_ether_addr mac;
uint32_t idx = 0;
lua_pushnil(L);
diff --git a/VNFs/DPPD-PROX/prox_lua_types.h b/VNFs/DPPD-PROX/prox_lua_types.h
index 182c9055..ce6bd9d2 100644
--- a/VNFs/DPPD-PROX/prox_lua_types.h
+++ b/VNFs/DPPD-PROX/prox_lua_types.h
@@ -21,10 +21,10 @@
#include <rte_ether.h>
#include <rte_hash.h>
+#include "prox_compat.h"
#include "ip6_addr.h"
struct lua_State;
-struct ether_addr;
struct ip4_subnet;
struct ip6_subnet;
struct next_hop;
@@ -70,7 +70,7 @@ struct lpm6 {
struct ipv6_tun_binding_entry {
struct ipv6_addr endpoint_addr; // IPv6 local addr
- struct ether_addr next_hop_mac; // mac addr of next hop towards lwB4
+ prox_rte_ether_addr next_hop_mac; // mac addr of next hop towards lwB4
uint32_t public_ipv4; // Public IPv4 address
uint16_t public_port; // Public base port (together with port mask, defines the Port Set)
} __attribute__((__packed__));
@@ -86,7 +86,7 @@ struct cpe_table_entry {
uint32_t svlan;
uint32_t cvlan;
uint32_t ip;
- struct ether_addr eth_addr;
+ prox_rte_ether_addr eth_addr;
uint32_t user;
};
@@ -115,7 +115,7 @@ int lua_getfrom(struct lua_State *L, enum lua_place from, const char *name);
int lua_to_port(struct lua_State *L, enum lua_place from, const char *name, uint16_t *port);
int lua_to_ip(struct lua_State *L, enum lua_place from, const char *name, uint32_t *ip);
int lua_to_ip6(struct lua_State *L, enum lua_place from, const char *name, uint8_t *ip);
-int lua_to_mac(struct lua_State *L, enum lua_place from, const char *name, struct ether_addr *mac);
+int lua_to_mac(struct lua_State *L, enum lua_place from, const char *name, prox_rte_ether_addr *mac);
int lua_to_cidr(struct lua_State *L, enum lua_place from, const char *name, struct ip4_subnet *cidr);
int lua_to_cidr6(struct lua_State *L, enum lua_place from, const char *name, struct ip6_subnet *cidr);
int lua_to_int(struct lua_State *L, enum lua_place from, const char *name, uint32_t *val);
diff --git a/VNFs/DPPD-PROX/prox_port_cfg.c b/VNFs/DPPD-PROX/prox_port_cfg.c
index 93341d3f..9af141f2 100644
--- a/VNFs/DPPD-PROX/prox_port_cfg.c
+++ b/VNFs/DPPD-PROX/prox_port_cfg.c
@@ -104,10 +104,10 @@ void prox_pktmbuf_init(struct rte_mempool *mp, void *opaque_arg, void *_m, unsig
struct rte_mbuf *mbuf = _m;
#if RTE_VERSION >= RTE_VERSION_NUM(1,8,0,0)
- mbuf->tx_offload = CALC_TX_OL(sizeof(struct ether_hdr), sizeof(struct ipv4_hdr));
+ mbuf->tx_offload = CALC_TX_OL(sizeof(prox_rte_ether_hdr), sizeof(prox_rte_ipv4_hdr));
#else
- mbuf->pkt.vlan_macip.f.l2_len = sizeof(struct ether_hdr);
- mbuf->pkt.vlan_macip.f.l3_len = sizeof(struct ipv4_hdr);
+ mbuf->pkt.vlan_macip.f.l2_len = sizeof(prox_rte_ether_hdr);
+ mbuf->pkt.vlan_macip.f.l3_len = sizeof(prox_rte_ipv4_hdr);
#endif
rte_pktmbuf_init(mp, opaque_arg, mbuf, i);
@@ -181,9 +181,9 @@ void init_rte_dev(int use_dummy_devices)
char port_name[32] = "0dummy_dev";
for (uint32_t i = 0; i < nb_ports; ++i) {
#if (RTE_VERSION > RTE_VERSION_NUM(17,5,0,1))
- rte_vdev_init(port_name, "size=ETHER_MIN_LEN,copy=0");
+ rte_vdev_init(port_name, "size=64,copy=0");
#else
- eth_dev_null_create(port_name, 0, ETHER_MIN_LEN, 0);
+ eth_dev_null_create(port_name, 0, PROX_RTE_ETHER_MIN_LEN, 0);
#endif
port_name[0]++;
}
@@ -505,7 +505,7 @@ static void init_port(struct prox_port_cfg *port_cfg)
dummy_pool_name[0]++;
} else {
// Most pmd should now support setting mtu
- if (port_cfg->mtu + ETHER_HDR_LEN + ETHER_CRC_LEN > port_cfg->max_rx_pkt_len) {
+ if (port_cfg->mtu + PROX_RTE_ETHER_HDR_LEN + PROX_RTE_ETHER_CRC_LEN > port_cfg->max_rx_pkt_len) {
plog_info("\t\tMTU is too big for the port, reducing MTU from %d to %d\n", port_cfg->mtu, port_cfg->max_rx_pkt_len);
port_cfg->mtu = port_cfg->max_rx_pkt_len;
}
@@ -779,7 +779,7 @@ void init_port_addr(void)
rte_eth_macaddr_get(port_id, &port_cfg->eth_addr);
break;
case PROX_PORT_MAC_RAND:
- eth_random_addr(port_cfg->eth_addr.addr_bytes);
+ prox_rte_eth_random_addr(port_cfg->eth_addr.addr_bytes);
break;
case PROX_PORT_MAC_SET:
if ((rc = rte_eth_dev_default_mac_addr_set(port_id, &port_cfg->eth_addr)) != 0)
diff --git a/VNFs/DPPD-PROX/prox_port_cfg.h b/VNFs/DPPD-PROX/prox_port_cfg.h
index 6a02cf0b..9a252c16 100644
--- a/VNFs/DPPD-PROX/prox_port_cfg.h
+++ b/VNFs/DPPD-PROX/prox_port_cfg.h
@@ -26,6 +26,7 @@
#endif
#include <rte_pci.h>
+#include "prox_compat.h"
#include "prox_globals.h"
enum addr_type {PROX_PORT_MAC_HW, PROX_PORT_MAC_SET, PROX_PORT_MAC_RAND};
@@ -53,7 +54,7 @@ struct prox_port_cfg {
uint32_t max_link_speed;
uint32_t mtu;
enum addr_type type;
- struct ether_addr eth_addr; /* port MAC address */
+ prox_rte_ether_addr eth_addr; /* port MAC address */
char name[MAX_NAME_SIZE];
char short_name[MAX_NAME_SIZE];
char driver_name[MAX_NAME_SIZE];
@@ -77,7 +78,7 @@ struct prox_port_cfg {
uint16_t min_tx_desc;
uint16_t max_tx_desc;
uint32_t nb_mc_addr;
- struct ether_addr mc_addr[NB_MCAST_ADDR];
+ prox_rte_ether_addr mc_addr[NB_MCAST_ADDR];
};
extern rte_atomic32_t lsc;
diff --git a/VNFs/DPPD-PROX/qinq.h b/VNFs/DPPD-PROX/qinq.h
index 14da9753..1d11114d 100644
--- a/VNFs/DPPD-PROX/qinq.h
+++ b/VNFs/DPPD-PROX/qinq.h
@@ -18,6 +18,7 @@
#define _QINQ_H_
#include <rte_ether.h>
+#include "prox_compat.h"
struct my_vlan_hdr {
uint16_t eth_proto;
@@ -30,8 +31,8 @@ struct vlans {
};
struct qinq_hdr {
- struct ether_addr d_addr;
- struct ether_addr s_addr;
+ prox_rte_ether_addr d_addr;
+ prox_rte_ether_addr s_addr;
struct my_vlan_hdr svlan;
struct my_vlan_hdr cvlan;
uint16_t ether_type;
diff --git a/VNFs/DPPD-PROX/quit.h b/VNFs/DPPD-PROX/quit.h
index d0bf8b95..c3cd0569 100644
--- a/VNFs/DPPD-PROX/quit.h
+++ b/VNFs/DPPD-PROX/quit.h
@@ -34,6 +34,8 @@
if (cond) { \
plog_info(__VA_ARGS__); \
display_end(); \
+ plog_end(); \
+ plog_info(__VA_ARGS__); \
if (prox_cfg.flags & DSF_DAEMON) { \
pid_t ppid = getppid(); \
plog_info("sending SIGUSR2 to %d\n", ppid);\
diff --git a/VNFs/DPPD-PROX/stats_latency.c b/VNFs/DPPD-PROX/stats_latency.c
index 7db53f20..58bad6fa 100644
--- a/VNFs/DPPD-PROX/stats_latency.c
+++ b/VNFs/DPPD-PROX/stats_latency.c
@@ -1,5 +1,5 @@
/*
-// Copyright (c) 2010-2017 Intel Corporation
+// Copyright (c) 2010-2019 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -22,6 +22,7 @@
struct stats_latency_manager_entry {
struct task_lat *task;
+ uint32_t bucket_size;
uint8_t lcore_id;
uint8_t task_id;
struct lat_test lat_test;
@@ -32,6 +33,7 @@ struct stats_latency_manager_entry {
struct stats_latency_manager {
uint16_t n_latency;
+ uint32_t bucket_size;
struct stats_latency_manager_entry entries[0]; /* copy of stats when running update stats. */
};
@@ -48,6 +50,11 @@ int stats_get_n_latency(void)
return slm->n_latency;
}
+int stats_get_latency_bucket_size(void)
+{
+ return slm->bucket_size;
+}
+
uint32_t stats_latency_get_core_id(uint32_t i)
{
return slm->entries[i].lcore_id;
@@ -63,6 +70,16 @@ struct stats_latency *stats_latency_get(uint32_t i)
return &slm->entries[i].stats;
}
+uint64_t *stats_latency_get_bucket(uint32_t i)
+{
+ return slm->entries[i].lat_test.buckets;
+}
+
+uint64_t *stats_latency_get_tot_bucket(uint32_t i)
+{
+ return slm->entries[i].tot_lat_test.buckets;
+}
+
struct stats_latency *stats_latency_tot_get(uint32_t i)
{
return &slm->entries[i].tot;
@@ -140,9 +157,14 @@ static void stats_latency_add_task(struct lcore_cfg *lconf, struct task_args *ta
struct stats_latency_manager_entry *new_entry = &slm->entries[slm->n_latency];
new_entry->task = (struct task_lat *)targ->tbase;
+ new_entry->bucket_size = task_lat_get_latency_bucket_size(new_entry->task);
new_entry->lcore_id = lconf->id;
new_entry->task_id = targ->id;
new_entry->tot_lat_test.min_lat = -1;
+ if (slm->bucket_size == 0)
+ slm->bucket_size = new_entry->bucket_size;
+ else if (slm->bucket_size != new_entry->bucket_size)
+ plog_err("Latency bucket size does not support different bucket sizes per task - using bucket size from first task (%d)\n", slm->bucket_size);
slm->n_latency++;
}
diff --git a/VNFs/DPPD-PROX/stats_latency.h b/VNFs/DPPD-PROX/stats_latency.h
index 83cd4a18..32f3ba34 100644
--- a/VNFs/DPPD-PROX/stats_latency.h
+++ b/VNFs/DPPD-PROX/stats_latency.h
@@ -1,5 +1,5 @@
/*
-// Copyright (c) 2010-2017 Intel Corporation
+// Copyright (c) 2010-2019 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -36,6 +36,8 @@ struct stats_latency {
uint32_t stats_latency_get_core_id(uint32_t i);
uint32_t stats_latency_get_task_id(uint32_t i);
struct stats_latency *stats_latency_get(uint32_t i);
+uint64_t *stats_latency_get_bucket(uint32_t i);
+uint64_t *stats_latency_get_tot_bucket(uint32_t i);
struct stats_latency *stats_latency_find(uint32_t lcore_id, uint32_t task_id);
struct stats_latency *stats_latency_tot_get(uint32_t i);
@@ -46,6 +48,7 @@ void stats_latency_update(void);
void stats_latency_reset(void);
int stats_get_n_latency(void);
+int stats_get_latency_bucket_size(void);
#ifdef LATENCY_HISTOGRAM
void stats_core_lat_histogram(uint8_t lcore_id, uint8_t task_id, uint64_t **buckets);
diff --git a/VNFs/DPPD-PROX/task_init.h b/VNFs/DPPD-PROX/task_init.h
index 9fa9f92b..4108f54d 100644
--- a/VNFs/DPPD-PROX/task_init.h
+++ b/VNFs/DPPD-PROX/task_init.h
@@ -22,6 +22,7 @@
#include <rte_common.h>
#include <rte_sched.h>
#include <rte_ether.h>
+#include "prox_compat.h"
#include "task_base.h"
#include "prox_globals.h"
#include "ip6_addr.h"
@@ -135,8 +136,8 @@ struct task_args {
struct rte_ring *tx_rings[MAX_RINGS_PER_TASK];
struct rte_ring *ctrl_plane_ring;
uint32_t tot_n_txrings_inited;
- struct ether_addr edaddr;
- struct ether_addr esaddr;
+ prox_rte_ether_addr edaddr;
+ prox_rte_ether_addr esaddr;
struct port_queue tx_port_queue[PROX_MAX_PORTS];
struct port_queue rx_port_queue[PROX_MAX_PORTS];
/* Used to set up actual task at initialization time. */
diff --git a/VNFs/DPPD-PROX/version.h b/VNFs/DPPD-PROX/version.h
index 171acc9c..727b2b80 100644
--- a/VNFs/DPPD-PROX/version.h
+++ b/VNFs/DPPD-PROX/version.h
@@ -19,7 +19,7 @@
/* PROGRAM_NAME defined through Makefile */
#define VERSION_MAJOR 0 // Pre-production
-#define VERSION_MINOR 1905 // 19.05 i.e. May 2019
+#define VERSION_MINOR 1908 // 19.08 i.e. August 2019
#define VERSION_REV 0
static inline char *VERSION_STR(void)
diff --git a/VNFs/DPPD-PROX/vxlangpe_nsh.h b/VNFs/DPPD-PROX/vxlangpe_nsh.h
index 5f83650c..7aebf380 100644
--- a/VNFs/DPPD-PROX/vxlangpe_nsh.h
+++ b/VNFs/DPPD-PROX/vxlangpe_nsh.h
@@ -36,12 +36,12 @@ struct nsh_hdr {
} __attribute__((__packed__));
#if RTE_VERSION < RTE_VERSION_NUM(18,5,0,0)
-struct vxlan_gpe_hdr {
+typedef struct prox_rte_vxlan_gpe_hdr {
uint8_t flag_0;
uint8_t flag_1;
uint8_t reserved;
uint8_t proto;
uint32_t vni_res;
-} __attribute__((__packed__));
+} __attribute__((__packed__)) prox_rte_vxlan_gpe_hdr;
#endif
#endif /* _VXLANGPE_NSH_H_ */