infra: transform loopback netdev from tun to tap

In order to forward non IP frames to the kernel, a full ethernet frame
is required.
Remove the direct injection of packets to ip(6)_input nodes, and rely on
the common nodes to direct the packets to the proper destination.

loopback_ouput now behaves similarly to eth_output, prepending an
ethernet header.

Following kernel behavior, do not add an ip6 link local to the vrf
iface.

Signed-off-by: Christophe Fontaine <[email protected]>

Author: christophefontaine

docs/graph.svg

@@ -9,4 +9,3 @@
 
 void loopback_tx(struct rte_mbuf *m);
 control_input_t loopback_get_control_id(void);
-void loopback_input_add_type(rte_be16_t eth_type, const char *next_node);

modules/infra/control/gr_loopback.h

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: BSD-3-Clause
 // Copyright (c) 2024 Christophe Fontaine
 
+#include <gr_config.h>
 #include <gr_control_input.h>
 #include <gr_control_output.h>
 #include <gr_eth.h>
@@ -14,6 +15,7 @@
 #include <event2/event.h>
 #include <rte_errno.h>
 #include <rte_malloc.h>
+#include <rte_net.h>
 
 #include <fcntl.h>
 #include <linux/if_tun.h>
@@ -32,6 +34,7 @@ static struct event_base *ev_base;
 struct iface_info_loopback {
 	int fd;
 	struct event *ev;
+	struct rte_ether_addr mac;
 };
 
 static void finalize_fd(struct event *ev, void * /*priv*/) {
@@ -40,14 +43,26 @@ static void finalize_fd(struct event *ev, void * /*priv*/) {
 		close(fd);
 }
 
+static int loopback_mac_get(const struct iface *iface, struct rte_ether_addr *mac) {
+	struct iface_info_loopback *lo = (struct iface_info_loopback *)iface->info;
+	*mac = lo->mac;
+	return 0;
+}
+
 void loopback_tx(struct rte_mbuf *m) {
 	struct mbuf_data *d = mbuf_data(m);
 	struct iface_info_loopback *lo;
-	struct iovec iov[2];
-	struct tun_pi pi;
-	char *data;
+	struct rte_ether_hdr *eth;
+	struct iface_stats *stats;
+	char *data = NULL;
 
 	lo = (struct iface_info_loopback *)d->iface->info;
+
+	eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
+	if (rte_is_broadcast_ether_addr(&eth->dst_addr) == 0)
+		loopback_mac_get(d->iface, &eth->dst_addr);
+	loopback_mac_get(d->iface, &eth->src_addr);
+
 	if (rte_pktmbuf_linearize(m) == 0) {
 		data = rte_pktmbuf_mtod(m, char *);
 	} else {
@@ -60,42 +75,41 @@ void loopback_tx(struct rte_mbuf *m) {
 		// to the user provided buffer.
 		rte_pktmbuf_read(m, 0, rte_pktmbuf_pkt_len(m), data);
 	}
-	pi.flags = 0;
-	if ((data[0] & 0xf0) == 0x40)
-		pi.proto = RTE_BE16(RTE_ETHER_TYPE_IPV4);
-	else if ((data[0] & 0xf0) == 0x60)
-		pi.proto = RTE_BE16(RTE_ETHER_TYPE_IPV6);
-	else {
-		LOG(ERR, "Bad proto: 0x%x - drop packet", data[0]);
-		goto end;
-	}
+
 	// Do not retry even in case of  if EAGAIN || EWOULDBLOCK
 	// If the tun device queue is full, something really bad is
 	// already happening on the management plane side.
-	iov[0].iov_base = &pi;
-	iov[0].iov_len = sizeof(pi);
-	iov[1].iov_base = data;
-	iov[1].iov_len = rte_pktmbuf_pkt_len(m);
-
-	if (writev(lo->fd, iov, ARRAY_DIM(iov)) < 0) {
+	if (write(lo->fd, data, rte_pktmbuf_pkt_len(m)) < 0) {
 		// The user messed up and removed gr-loopX
 		// release resources on our side to try to recover
 		if (errno == EBADFD) {
 			iface_destroy(d->iface->id);
 		}
-		LOG(ERR, "write to tun device failed %s", strerror(errno));
+		LOG(ERR, "write to tap device failed %s", strerror(errno));
 	}
 
+	stats = iface_get_stats(rte_lcore_id(), d->iface->id);
+	stats->tx_packets += 1;
+	stats->tx_bytes += rte_pktmbuf_pkt_len(m);
+
+	if (gr_config.log_packets)
+		trace_log_packet(m, "tx", d->iface->name);
+
+	// TODO: add a trace for that fake node
+	if (gr_mbuf_is_traced(m))
+		gr_mbuf_trace_finish(m);
 end:
 	if (!rte_pktmbuf_is_contiguous(m))
 		rte_free(data);
 	rte_pktmbuf_free(m);
 }
 
 static void iface_loopback_poll(evutil_socket_t, short reason, void *ev_iface) {
-	struct eth_input_mbuf_data *e;
 	struct iface_info_loopback *lo;
 	struct iface *iface = ev_iface;
+	struct eth_input_mbuf_data *e;
+	struct rte_ether_hdr *eth;
+	struct iface_stats *stats;
 	struct rte_mbuf *mbuf;
 	size_t read_len;
 	size_t len;
@@ -105,7 +119,7 @@ static void iface_loopback_poll(evutil_socket_t, short reason, void *ev_iface) {
 
 	if (reason & EV_CLOSED) {
 		// The user messed up and removed gr-loopX
-		LOG(ERR, "tun device %s deleted", iface->name);
+		LOG(ERR, "tap device %s deleted", iface->name);
 		iface_destroy(iface->id);
 		return;
 	}
@@ -116,7 +130,7 @@ static void iface_loopback_poll(evutil_socket_t, short reason, void *ev_iface) {
 		goto err;
 	}
 
-	read_len = iface->mtu + sizeof(struct tun_pi);
+	read_len = iface->mtu;
 	if ((data = rte_pktmbuf_append(mbuf, read_len)) == NULL) {
 		LOG(ERR, "rte_pktmbuf_alloc %s", rte_strerror(rte_errno));
 		goto err;
@@ -130,20 +144,28 @@ static void iface_loopback_poll(evutil_socket_t, short reason, void *ev_iface) {
 	}
 
 	rte_pktmbuf_trim(mbuf, read_len - len);
+	eth = rte_pktmbuf_mtod(mbuf, struct rte_ether_hdr *);
+
+	if (rte_is_broadcast_ether_addr(&eth->dst_addr) == 0)
+		loopback_mac_get(iface, &eth->dst_addr);
 
 	// packet sent from linux tun iface, no need to compute checksum;
 	mbuf->ol_flags = RTE_MBUF_F_RX_IP_CKSUM_GOOD;
+	mbuf->packet_type = rte_net_get_ptype(mbuf, NULL, RTE_PTYPE_ALL_MASK);
 
-	// We can't call rte_net_get_ptype directly as we do not have an ethernet frame.
-	// An option would be to prepend/adjust every buffer, but let's set directly
-	// the information we need instead.
-	mbuf->packet_type = data[0] == 6 ? RTE_PTYPE_L3_IPV6 : RTE_PTYPE_L3_IPV4;
-
-	// required by ip(6)_input
 	e = eth_input_mbuf_data(mbuf);
 	e->iface = iface;
 	e->domain = ETH_DOMAIN_LOOPBACK;
 
+	stats = iface_get_stats(rte_lcore_id(), iface->id);
+	stats->rx_packets += 1;
+	stats->rx_bytes += rte_pktmbuf_pkt_len(mbuf);
+
+	if (gr_config.log_packets)
+		trace_log_packet(mbuf, "rx", iface->name);
+
+	// TODO: add trace for that fake node
+
 	post_to_stack(loopback_get_control_id(), mbuf);
 	return;
 
@@ -175,7 +197,7 @@ static int iface_loopback_init(struct iface *iface, const void * /* api_info */)
 
 	memset(&ifr, 0, sizeof(struct ifreq));
 	memccpy(ifr.ifr_name, iface->name, 0, IFNAMSIZ);
-	ifr.ifr_flags = IFF_TUN | IFF_POINTOPOINT | IFF_ONE_QUEUE;
+	ifr.ifr_flags = IFF_TAP | IFF_ONE_QUEUE | IFF_NO_PI;
 
 	if ((ioctl_sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 		LOG(ERR, "socket(SOCK_DGRAM): %s", strerror(errno));
@@ -209,12 +231,18 @@ static int iface_loopback_init(struct iface *iface, const void * /* api_info */)
 		goto err;
 	}
 
-	ifr.ifr_flags |= IFF_UP;
+	ifr.ifr_flags |= IFF_UP | IFF_NOARP;
 	if (ioctl(ioctl_sock, SIOCSIFFLAGS, &ifr) < 0) {
 		LOG(ERR, "ioctl(SIOCSIFFLAGS): %s", strerror(errno));
 		goto err;
 	}
 
+	if (ioctl(ioctl_sock, SIOCGIFHWADDR, &ifr) < 0) {
+		LOG(ERR, "ioctl(SIOCGIFHWADDR) %s", strerror(errno));
+		goto err;
+	}
+	memcpy(&lo->mac, ifr.ifr_hwaddr.sa_data, sizeof(lo->mac));
+
 	iface->flags = GR_IFACE_F_UP;
 	iface->state = GR_IFACE_S_RUNNING;
 	lo->ev = event_new(
@@ -267,6 +295,7 @@ static struct iface_type iface_type_loopback = {
 	.init = iface_loopback_init,
 	.fini = iface_loopback_fini,
 	.to_api = iface_loopback_to_api,
+	.get_eth_addr = loopback_mac_get,
 };
 
 static struct gr_module loopback_module = {

modules/infra/control/loopback.c

@@ -90,6 +90,9 @@ eth_input_process(struct rte_graph *graph, struct rte_node *node, void **objs, u
 		stats->rx_packets += 1;
 		stats->rx_bytes += rte_pktmbuf_pkt_len(m);
 
+		if (unlikely(eth_in->domain == ETH_DOMAIN_LOOPBACK))
+			goto next;
+
 		if (unlikely(rte_is_multicast_ether_addr(&eth->dst_addr))) {
 			if (rte_is_broadcast_ether_addr(&eth->dst_addr))
 				eth_in->domain = ETH_DOMAIN_BROADCAST;

modules/infra/datapath/eth_input.c

@@ -18,43 +18,27 @@ control_input_t loopback_get_control_id(void) {
 }
 
 enum {
-	UNKNOWN_PROTO = 0,
+	ETH = 0,
 	EDGE_COUNT,
 };
 
-static rte_edge_t l3_edges[1 << 16] = {UNKNOWN_PROTO};
-
-void loopback_input_add_type(rte_be16_t eth_type, const char *next_node) {
-	LOG(DEBUG, "loopback_input: type=0x%04x -> %s", rte_be_to_cpu_16(eth_type), next_node);
-	if (l3_edges[eth_type] != UNKNOWN_PROTO)
-		ABORT("next node already registered for ether type=0x%04x",
-		      rte_be_to_cpu_16(eth_type));
-	l3_edges[eth_type] = gr_node_attach_parent("loopback_input", next_node);
-}
-
 static uint16_t loopback_input_process(
 	struct rte_graph *graph,
 	struct rte_node *node,
 	void **objs,
 	uint16_t nb_objs
 ) {
 	struct rte_mbuf *mbuf;
-	rte_be16_t eth_type;
-	rte_edge_t edge;
 
 	for (uint16_t i = 0; i < nb_objs; i++) {
 		mbuf = objs[i];
-
 		if (gr_mbuf_is_traced(mbuf)
 		    || mbuf_data(mbuf)->iface->flags & GR_IFACE_F_PACKET_TRACE) {
 			gr_mbuf_trace_add(mbuf, node, 0);
 		}
-
-		eth_type = rte_pktmbuf_mtod(mbuf, struct tun_pi *)->proto;
-		rte_pktmbuf_adj(mbuf, sizeof(struct tun_pi));
-		edge = l3_edges[eth_type];
-		rte_node_enqueue_x1(graph, node, edge, mbuf);
 	}
+	rte_node_enqueue(graph, node, ETH, objs, nb_objs);
+
 	return nb_objs;
 }
 
@@ -63,7 +47,7 @@ static struct rte_node_register loopback_input_node = {
 	.process = loopback_input_process,
 	.nb_edges = EDGE_COUNT,
 	.next_nodes = {
-		[UNKNOWN_PROTO] = "loopback_unknown_proto",
+		[ETH] = "eth_input",
 	},
 };
 
@@ -77,4 +61,3 @@ static struct gr_node_info info = {
 };
 
 GR_NODE_REGISTER(info);
-GR_DROP_REGISTER(loopback_unknown_proto);

modules/infra/datapath/loop_input.c

@@ -2,6 +2,7 @@
 // Copyright (c) 2024 Christophe Fontaine
 
 #include <gr_control_output.h>
+#include <gr_eth.h>
 #include <gr_graph.h>
 #include <gr_infra.h>
 #include <gr_ip4_datapath.h>
@@ -11,6 +12,7 @@
 
 enum {
 	CONTROL_OUTPUT,
+	NO_HEADROOM,
 	EDGE_COUNT,
 };
 
@@ -20,14 +22,28 @@ static uint16_t loopback_output_process(
 	void **objs,
 	uint16_t nb_objs
 ) {
+	struct eth_output_mbuf_data *eth_data;
 	struct control_output_mbuf_data *co;
+	struct rte_ether_hdr *eth;
 	struct rte_mbuf *mbuf;
+	rte_edge_t edge;
 
 	for (uint16_t i = 0; i < nb_objs; i++) {
 		mbuf = objs[i];
+		edge = CONTROL_OUTPUT;
+		eth_data = eth_output_mbuf_data(mbuf);
+		eth = (struct rte_ether_hdr *)rte_pktmbuf_prepend(mbuf, sizeof(*eth));
+		if (eth == NULL) {
+			edge = NO_HEADROOM;
+			goto next;
+		}
+
+		eth->ether_type = eth_data->ether_type;
+
 		co = control_output_mbuf_data(mbuf);
 		co->callback = loopback_tx;
-		rte_node_enqueue_x1(graph, node, CONTROL_OUTPUT, mbuf);
+next:
+		rte_node_enqueue_x1(graph, node, edge, mbuf);
 	}
 	return nb_objs;
 }
@@ -38,6 +54,7 @@ static struct rte_node_register loopback_output_node = {
 	.nb_edges = EDGE_COUNT,
 	.next_nodes = {
 		[CONTROL_OUTPUT] = "control_output",
+		[NO_HEADROOM] = "error_no_headroom",
 	},
 };
 

modules/infra/datapath/loop_output.c

@@ -158,7 +158,6 @@ ip_input_process(struct rte_graph *graph, struct rte_node *node, void **objs, ui
 
 static void ip_input_register(void) {
 	gr_eth_input_add_type(RTE_BE16(RTE_ETHER_TYPE_IPV4), "ip_input");
-	loopback_input_add_type(RTE_BE16(RTE_ETHER_TYPE_IPV4), "ip_input");
 }
 
 static struct rte_node_register input_node = {
@@ -204,7 +203,6 @@ mock_func(uint16_t, drop_packets(struct rte_graph *, struct rte_node *, void **,
 mock_func(int, drop_format(char *, size_t, const void *, size_t));
 mock_func(int, trace_ip_format(char *, size_t, const struct rte_ipv4_hdr *, size_t));
 mock_func(void, gr_eth_input_add_type(rte_be16_t, const char *));
-mock_func(void, loopback_input_add_type(rte_be16_t, const char *));
 
 struct fake_mbuf {
 	struct rte_ipv4_hdr ipv4_hdr;

modules/ip/datapath/ip_input.c

@@ -323,6 +323,8 @@ static void ip6_iface_event_handler(uint32_t event, const void *obj) {
 
 	switch (event) {
 	case GR_EVENT_IFACE_POST_ADD:
+		if (iface->type == GR_IFACE_TYPE_LOOPBACK)
+			break;
 		if (iface_get_eth_addr(iface->id, &mac) == 0) {
 			rte_ipv6_llocal_from_ethernet(&link_local, &mac);
 			if (iface6_addr_add(iface, &link_local, 64) < 0)

modules/ip6/control/address.c

@@ -151,7 +151,6 @@ ip6_input_process(struct rte_graph *graph, struct rte_node *node, void **objs, u
 
 static void ip6_input_register(void) {
 	gr_eth_input_add_type(RTE_BE16(RTE_ETHER_TYPE_IPV6), "ip6_input");
-	loopback_input_add_type(RTE_BE16(RTE_ETHER_TYPE_IPV6), "ip6_input");
 }
 
 static struct rte_node_register input_node = {
@@ -200,7 +199,6 @@ mock_func(uint16_t, drop_packets(struct rte_graph *, struct rte_node *, void **,
 mock_func(int, drop_format(char *, size_t, const void *, size_t));
 mock_func(int, trace_ip6_format(char *, size_t, const struct rte_ipv6_hdr *, size_t));
 mock_func(void, gr_eth_input_add_type(rte_be16_t, const char *));
-mock_func(void, loopback_input_add_type(rte_be16_t, const char *));
 mock_func(struct nexthop *, mcast6_get_member(uint16_t, const struct rte_ipv6_addr *));
 
 struct fake_mbuf {