Commit 91dda69b authored by Toke Høiland-Jørgensen's avatar Toke Høiland-Jørgensen Committed by Alexei Starovoitov
Browse files

samples/bpf: Remove the xdp_redirect* utilities 



These utilities have all been ported to xdp-tools as functions of the
xdp-bench utility. The four different utilities in samples are incorporated
as separate subcommands to xdp-bench, with most of the command line
parameters left intact, except that mandatory arguments are always
positional in xdp-bench. For full usage details see the --help output of
each command, or the xdp-bench man page.

Some examples of how to convert usage to xdp-bench are:

xdp_redirect eth0 eth1
  --> xdp-bench redirect eth0 eth1

xdp_redirect_map eth0 eth1
  --> xdp-bench redirect-map eth0 eth1

xdp_redirect_map_multi eth0 eth1 eth2 eth3
  --> xdp-bench redirect-multi eth0 eth1 eth2 eth3

xdp_redirect_cpu -d eth0 -c 0 -c 1
  --> xdp-bench redirect-cpu -c 0 -c 1 eth0

xdp_redirect_cpu -d eth0 -c 0 -c 1 -r eth1
  --> xdp-bench redirect-cpu -c 0 -c 1 eth0 -r redirect -D eth1

Signed-off-by: default avatarToke Høiland-Jørgensen <toke@redhat.com>
Link: https://lore.kernel.org/r/20230824102255.1561885-3-toke@redhat.com


Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parent e7c9e73d

samples/bpf/Makefile

+1 −28
Original line number Diff line number Diff line
@@ -51,11 +51,6 @@ tprogs-y += xdp_sample_pkts 
tprogs-y += ibumad

tprogs-y += hbm



tprogs-y += xdp_redirect_cpu

tprogs-y += xdp_redirect_map_multi

tprogs-y += xdp_redirect_map

tprogs-y += xdp_redirect



# Libbpf dependencies

LIBBPF_SRC = $(TOOLS_PATH)/lib/bpf

LIBBPF_OUTPUT = $(abspath $(BPF_SAMPLES_PATH))/libbpf
@@ -111,10 +106,6 @@ xdp_sample_pkts-objs := xdp_sample_pkts_user.o 
ibumad-objs := ibumad_user.o

hbm-objs := hbm.o $(CGROUP_HELPERS)



xdp_redirect_map_multi-objs := xdp_redirect_map_multi_user.o $(XDP_SAMPLE)

xdp_redirect_cpu-objs := xdp_redirect_cpu_user.o $(XDP_SAMPLE)

xdp_redirect_map-objs := xdp_redirect_map_user.o $(XDP_SAMPLE)

xdp_redirect-objs := xdp_redirect_user.o $(XDP_SAMPLE)

xdp_router_ipv4-objs := xdp_router_ipv4_user.o $(XDP_SAMPLE)



# Tell kbuild to always build the programs
@@ -205,10 +196,6 @@ TPROGS_LDFLAGS := -L$(SYSROOT)/usr/lib 
endif



TPROGS_LDLIBS			+= $(LIBBPF) -lelf -lz

TPROGLDLIBS_xdp_redirect	+= -lm

TPROGLDLIBS_xdp_redirect_cpu	+= -lm

TPROGLDLIBS_xdp_redirect_map	+= -lm

TPROGLDLIBS_xdp_redirect_map_multi += -lm

TPROGLDLIBS_xdp_router_ipv4	+= -lm -pthread

TPROGLDLIBS_tracex4		+= -lrt

TPROGLDLIBS_trace_output	+= -lrt
@@ -323,10 +310,6 @@ $(obj)/$(TRACE_HELPERS) $(obj)/$(CGROUP_HELPERS) $(obj)/$(XDP_SAMPLE): | libbpf_ 


.PHONY: libbpf_hdrs



$(obj)/xdp_redirect_cpu_user.o: $(obj)/xdp_redirect_cpu.skel.h

$(obj)/xdp_redirect_map_multi_user.o: $(obj)/xdp_redirect_map_multi.skel.h

$(obj)/xdp_redirect_map_user.o: $(obj)/xdp_redirect_map.skel.h

$(obj)/xdp_redirect_user.o: $(obj)/xdp_redirect.skel.h

$(obj)/xdp_router_ipv4_user.o: $(obj)/xdp_router_ipv4.skel.h



$(obj)/tracex5.bpf.o: $(obj)/syscall_nrs.h
@@ -379,10 +362,6 @@ endef 


CLANG_SYS_INCLUDES = $(call get_sys_includes,$(CLANG))



$(obj)/xdp_redirect_cpu.bpf.o: $(obj)/xdp_sample.bpf.o

$(obj)/xdp_redirect_map_multi.bpf.o: $(obj)/xdp_sample.bpf.o

$(obj)/xdp_redirect_map.bpf.o: $(obj)/xdp_sample.bpf.o

$(obj)/xdp_redirect.bpf.o: $(obj)/xdp_sample.bpf.o

$(obj)/xdp_router_ipv4.bpf.o: $(obj)/xdp_sample.bpf.o



$(obj)/%.bpf.o: $(src)/%.bpf.c $(obj)/vmlinux.h $(src)/xdp_sample.bpf.h $(src)/xdp_sample_shared.h
@@ -393,15 +372,9 @@ $(obj)/%.bpf.o: $(src)/%.bpf.c $(obj)/vmlinux.h $(src)/xdp_sample.bpf.h $(src)/x 
		-I$(LIBBPF_INCLUDE) $(CLANG_SYS_INCLUDES) \

		-c $(filter %.bpf.c,$^) -o $@



LINKED_SKELS := xdp_redirect_cpu.skel.h xdp_redirect_map_multi.skel.h \

		xdp_redirect_map.skel.h xdp_redirect.skel.h \

		xdp_router_ipv4.skel.h

LINKED_SKELS := xdp_router_ipv4.skel.h

clean-files += $(LINKED_SKELS)



xdp_redirect_cpu.skel.h-deps := xdp_redirect_cpu.bpf.o xdp_sample.bpf.o

xdp_redirect_map_multi.skel.h-deps := xdp_redirect_map_multi.bpf.o xdp_sample.bpf.o

xdp_redirect_map.skel.h-deps := xdp_redirect_map.bpf.o xdp_sample.bpf.o

xdp_redirect.skel.h-deps := xdp_redirect.bpf.o xdp_sample.bpf.o

xdp_router_ipv4.skel.h-deps := xdp_router_ipv4.bpf.o xdp_sample.bpf.o



LINKED_BPF_SRCS := $(patsubst %.bpf.o,%.bpf.c,$(foreach skel,$(LINKED_SKELS),$($(skel)-deps)))

samples/bpf/xdp_redirect.bpf.c

deleted100644 → 0
+0 −49
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/* Copyright (c) 2016 John Fastabend <john.r.fastabend@intel.com>

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of version 2 of the GNU General Public

 * License as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

 * General Public License for more details.

 */

#include "vmlinux.h"

#include "xdp_sample.bpf.h"

#include "xdp_sample_shared.h"



const volatile int ifindex_out;



SEC("xdp")

int xdp_redirect_prog(struct xdp_md *ctx)

{

	void *data_end = (void *)(long)ctx->data_end;

	void *data = (void *)(long)ctx->data;

	u32 key = bpf_get_smp_processor_id();

	struct ethhdr *eth = data;

	struct datarec *rec;

	u64 nh_off;



	nh_off = sizeof(*eth);

	if (data + nh_off > data_end)

		return XDP_DROP;



	rec = bpf_map_lookup_elem(&rx_cnt, &key);

	if (!rec)

		return XDP_PASS;

	NO_TEAR_INC(rec->processed);



	swap_src_dst_mac(data);

	return bpf_redirect(ifindex_out, 0);

}



/* Redirect require an XDP bpf_prog loaded on the TX device */

SEC("xdp")

int xdp_redirect_dummy_prog(struct xdp_md *ctx)

{

	return XDP_PASS;

}



char _license[] SEC("license") = "GPL";

samples/bpf/xdp_redirect_cpu.bpf.c

deleted100644 → 0
+0 −539
Original line number Diff line number Diff line 
/*  XDP redirect to CPUs via cpumap (BPF_MAP_TYPE_CPUMAP)

 *

 *  GPLv2, Copyright(c) 2017 Jesper Dangaard Brouer, Red Hat, Inc.

 */

#include "vmlinux.h"

#include "xdp_sample.bpf.h"

#include "xdp_sample_shared.h"

#include "hash_func01.h"



/* Special map type that can XDP_REDIRECT frames to another CPU */

struct {

	__uint(type, BPF_MAP_TYPE_CPUMAP);

	__uint(key_size, sizeof(u32));

	__uint(value_size, sizeof(struct bpf_cpumap_val));

} cpu_map SEC(".maps");



/* Set of maps controlling available CPU, and for iterating through

 * selectable redirect CPUs.

 */

struct {

	__uint(type, BPF_MAP_TYPE_ARRAY);

	__type(key, u32);

	__type(value, u32);

} cpus_available SEC(".maps");



struct {

	__uint(type, BPF_MAP_TYPE_ARRAY);

	__type(key, u32);

	__type(value, u32);

	__uint(max_entries, 1);

} cpus_count SEC(".maps");



struct {

	__uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);

	__type(key, u32);

	__type(value, u32);

	__uint(max_entries, 1);

} cpus_iterator SEC(".maps");



struct {

	__uint(type, BPF_MAP_TYPE_DEVMAP);

	__uint(key_size, sizeof(int));

	__uint(value_size, sizeof(struct bpf_devmap_val));

	__uint(max_entries, 1);

} tx_port SEC(".maps");



char tx_mac_addr[ETH_ALEN];



/* Helper parse functions */



static __always_inline

bool parse_eth(struct ethhdr *eth, void *data_end,

	       u16 *eth_proto, u64 *l3_offset)

{

	u16 eth_type;

	u64 offset;



	offset = sizeof(*eth);

	if ((void *)eth + offset > data_end)

		return false;



	eth_type = eth->h_proto;



	/* Skip non 802.3 Ethertypes */

	if (__builtin_expect(bpf_ntohs(eth_type) < ETH_P_802_3_MIN, 0))

		return false;



	/* Handle VLAN tagged packet */

	if (eth_type == bpf_htons(ETH_P_8021Q) ||

	    eth_type == bpf_htons(ETH_P_8021AD)) {

		struct vlan_hdr *vlan_hdr;



		vlan_hdr = (void *)eth + offset;

		offset += sizeof(*vlan_hdr);

		if ((void *)eth + offset > data_end)

			return false;

		eth_type = vlan_hdr->h_vlan_encapsulated_proto;

	}

	/* Handle double VLAN tagged packet */

	if (eth_type == bpf_htons(ETH_P_8021Q) ||

	    eth_type == bpf_htons(ETH_P_8021AD)) {

		struct vlan_hdr *vlan_hdr;



		vlan_hdr = (void *)eth + offset;

		offset += sizeof(*vlan_hdr);

		if ((void *)eth + offset > data_end)

			return false;

		eth_type = vlan_hdr->h_vlan_encapsulated_proto;

	}



	*eth_proto = bpf_ntohs(eth_type);

	*l3_offset = offset;

	return true;

}



static __always_inline

u16 get_dest_port_ipv4_udp(struct xdp_md *ctx, u64 nh_off)

{

	void *data_end = (void *)(long)ctx->data_end;

	void *data     = (void *)(long)ctx->data;

	struct iphdr *iph = data + nh_off;

	struct udphdr *udph;



	if (iph + 1 > data_end)

		return 0;

	if (!(iph->protocol == IPPROTO_UDP))

		return 0;



	udph = (void *)(iph + 1);

	if (udph + 1 > data_end)

		return 0;



	return bpf_ntohs(udph->dest);

}



static __always_inline

int get_proto_ipv4(struct xdp_md *ctx, u64 nh_off)

{

	void *data_end = (void *)(long)ctx->data_end;

	void *data     = (void *)(long)ctx->data;

	struct iphdr *iph = data + nh_off;



	if (iph + 1 > data_end)

		return 0;

	return iph->protocol;

}



static __always_inline

int get_proto_ipv6(struct xdp_md *ctx, u64 nh_off)

{

	void *data_end = (void *)(long)ctx->data_end;

	void *data     = (void *)(long)ctx->data;

	struct ipv6hdr *ip6h = data + nh_off;



	if (ip6h + 1 > data_end)

		return 0;

	return ip6h->nexthdr;

}



SEC("xdp")

int  xdp_prognum0_no_touch(struct xdp_md *ctx)

{

	u32 key = bpf_get_smp_processor_id();

	struct datarec *rec;

	u32 *cpu_selected;

	u32 cpu_dest = 0;

	u32 key0 = 0;



	/* Only use first entry in cpus_available */

	cpu_selected = bpf_map_lookup_elem(&cpus_available, &key0);

	if (!cpu_selected)

		return XDP_ABORTED;

	cpu_dest = *cpu_selected;



	rec = bpf_map_lookup_elem(&rx_cnt, &key);

	if (!rec)

		return XDP_PASS;

	NO_TEAR_INC(rec->processed);



	if (cpu_dest >= nr_cpus) {

		NO_TEAR_INC(rec->issue);

		return XDP_ABORTED;

	}

	return bpf_redirect_map(&cpu_map, cpu_dest, 0);

}



SEC("xdp")

int  xdp_prognum1_touch_data(struct xdp_md *ctx)

{

	void *data_end = (void *)(long)ctx->data_end;

	void *data     = (void *)(long)ctx->data;

	u32 key = bpf_get_smp_processor_id();

	struct ethhdr *eth = data;

	struct datarec *rec;

	u32 *cpu_selected;

	u32 cpu_dest = 0;

	u32 key0 = 0;

	u16 eth_type;



	/* Only use first entry in cpus_available */

	cpu_selected = bpf_map_lookup_elem(&cpus_available, &key0);

	if (!cpu_selected)

		return XDP_ABORTED;

	cpu_dest = *cpu_selected;



	/* Validate packet length is minimum Eth header size */

	if (eth + 1 > data_end)

		return XDP_ABORTED;



	rec = bpf_map_lookup_elem(&rx_cnt, &key);

	if (!rec)

		return XDP_PASS;

	NO_TEAR_INC(rec->processed);



	/* Read packet data, and use it (drop non 802.3 Ethertypes) */

	eth_type = eth->h_proto;

	if (bpf_ntohs(eth_type) < ETH_P_802_3_MIN) {

		NO_TEAR_INC(rec->dropped);

		return XDP_DROP;

	}



	if (cpu_dest >= nr_cpus) {

		NO_TEAR_INC(rec->issue);

		return XDP_ABORTED;

	}

	return bpf_redirect_map(&cpu_map, cpu_dest, 0);

}



SEC("xdp")

int  xdp_prognum2_round_robin(struct xdp_md *ctx)

{

	void *data_end = (void *)(long)ctx->data_end;

	void *data     = (void *)(long)ctx->data;

	u32 key = bpf_get_smp_processor_id();

	struct datarec *rec;

	u32 cpu_dest = 0;

	u32 key0 = 0;



	u32 *cpu_selected;

	u32 *cpu_iterator;

	u32 *cpu_max;

	u32 cpu_idx;



	cpu_max = bpf_map_lookup_elem(&cpus_count, &key0);

	if (!cpu_max)

		return XDP_ABORTED;



	cpu_iterator = bpf_map_lookup_elem(&cpus_iterator, &key0);

	if (!cpu_iterator)

		return XDP_ABORTED;

	cpu_idx = *cpu_iterator;



	*cpu_iterator += 1;

	if (*cpu_iterator == *cpu_max)

		*cpu_iterator = 0;



	cpu_selected = bpf_map_lookup_elem(&cpus_available, &cpu_idx);

	if (!cpu_selected)

		return XDP_ABORTED;

	cpu_dest = *cpu_selected;



	rec = bpf_map_lookup_elem(&rx_cnt, &key);

	if (!rec)

		return XDP_PASS;

	NO_TEAR_INC(rec->processed);



	if (cpu_dest >= nr_cpus) {

		NO_TEAR_INC(rec->issue);

		return XDP_ABORTED;

	}

	return bpf_redirect_map(&cpu_map, cpu_dest, 0);

}



SEC("xdp")

int  xdp_prognum3_proto_separate(struct xdp_md *ctx)

{

	void *data_end = (void *)(long)ctx->data_end;

	void *data     = (void *)(long)ctx->data;

	u32 key = bpf_get_smp_processor_id();

	struct ethhdr *eth = data;

	u8 ip_proto = IPPROTO_UDP;

	struct datarec *rec;

	u16 eth_proto = 0;

	u64 l3_offset = 0;

	u32 cpu_dest = 0;

	u32 *cpu_lookup;

	u32 cpu_idx = 0;



	rec = bpf_map_lookup_elem(&rx_cnt, &key);

	if (!rec)

		return XDP_PASS;

	NO_TEAR_INC(rec->processed);



	if (!(parse_eth(eth, data_end, &eth_proto, &l3_offset)))

		return XDP_PASS; /* Just skip */



	/* Extract L4 protocol */

	switch (eth_proto) {

	case ETH_P_IP:

		ip_proto = get_proto_ipv4(ctx, l3_offset);

		break;

	case ETH_P_IPV6:

		ip_proto = get_proto_ipv6(ctx, l3_offset);

		break;

	case ETH_P_ARP:

		cpu_idx = 0; /* ARP packet handled on separate CPU */

		break;

	default:

		cpu_idx = 0;

	}



	/* Choose CPU based on L4 protocol */

	switch (ip_proto) {

	case IPPROTO_ICMP:

	case IPPROTO_ICMPV6:

		cpu_idx = 2;

		break;

	case IPPROTO_TCP:

		cpu_idx = 0;

		break;

	case IPPROTO_UDP:

		cpu_idx = 1;

		break;

	default:

		cpu_idx = 0;

	}



	cpu_lookup = bpf_map_lookup_elem(&cpus_available, &cpu_idx);

	if (!cpu_lookup)

		return XDP_ABORTED;

	cpu_dest = *cpu_lookup;



	if (cpu_dest >= nr_cpus) {

		NO_TEAR_INC(rec->issue);

		return XDP_ABORTED;

	}

	return bpf_redirect_map(&cpu_map, cpu_dest, 0);

}



SEC("xdp")

int  xdp_prognum4_ddos_filter_pktgen(struct xdp_md *ctx)

{

	void *data_end = (void *)(long)ctx->data_end;

	void *data     = (void *)(long)ctx->data;

	u32 key = bpf_get_smp_processor_id();

	struct ethhdr *eth = data;

	u8 ip_proto = IPPROTO_UDP;

	struct datarec *rec;

	u16 eth_proto = 0;

	u64 l3_offset = 0;

	u32 cpu_dest = 0;

	u32 *cpu_lookup;

	u32 cpu_idx = 0;

	u16 dest_port;



	rec = bpf_map_lookup_elem(&rx_cnt, &key);

	if (!rec)

		return XDP_PASS;

	NO_TEAR_INC(rec->processed);



	if (!(parse_eth(eth, data_end, &eth_proto, &l3_offset)))

		return XDP_PASS; /* Just skip */



	/* Extract L4 protocol */

	switch (eth_proto) {

	case ETH_P_IP:

		ip_proto = get_proto_ipv4(ctx, l3_offset);

		break;

	case ETH_P_IPV6:

		ip_proto = get_proto_ipv6(ctx, l3_offset);

		break;

	case ETH_P_ARP:

		cpu_idx = 0; /* ARP packet handled on separate CPU */

		break;

	default:

		cpu_idx = 0;

	}



	/* Choose CPU based on L4 protocol */

	switch (ip_proto) {

	case IPPROTO_ICMP:

	case IPPROTO_ICMPV6:

		cpu_idx = 2;

		break;

	case IPPROTO_TCP:

		cpu_idx = 0;

		break;

	case IPPROTO_UDP:

		cpu_idx = 1;

		/* DDoS filter UDP port 9 (pktgen) */

		dest_port = get_dest_port_ipv4_udp(ctx, l3_offset);

		if (dest_port == 9) {

			NO_TEAR_INC(rec->dropped);

			return XDP_DROP;

		}

		break;

	default:

		cpu_idx = 0;

	}



	cpu_lookup = bpf_map_lookup_elem(&cpus_available, &cpu_idx);

	if (!cpu_lookup)

		return XDP_ABORTED;

	cpu_dest = *cpu_lookup;



	if (cpu_dest >= nr_cpus) {

		NO_TEAR_INC(rec->issue);

		return XDP_ABORTED;

	}

	return bpf_redirect_map(&cpu_map, cpu_dest, 0);

}



/* Hashing initval */

#define INITVAL 15485863



static __always_inline

u32 get_ipv4_hash_ip_pair(struct xdp_md *ctx, u64 nh_off)

{

	void *data_end = (void *)(long)ctx->data_end;

	void *data     = (void *)(long)ctx->data;

	struct iphdr *iph = data + nh_off;

	u32 cpu_hash;



	if (iph + 1 > data_end)

		return 0;



	cpu_hash = iph->saddr + iph->daddr;

	cpu_hash = SuperFastHash((char *)&cpu_hash, 4, INITVAL + iph->protocol);



	return cpu_hash;

}



static __always_inline

u32 get_ipv6_hash_ip_pair(struct xdp_md *ctx, u64 nh_off)

{

	void *data_end = (void *)(long)ctx->data_end;

	void *data     = (void *)(long)ctx->data;

	struct ipv6hdr *ip6h = data + nh_off;

	u32 cpu_hash;



	if (ip6h + 1 > data_end)

		return 0;



	cpu_hash  = ip6h->saddr.in6_u.u6_addr32[0] + ip6h->daddr.in6_u.u6_addr32[0];

	cpu_hash += ip6h->saddr.in6_u.u6_addr32[1] + ip6h->daddr.in6_u.u6_addr32[1];

	cpu_hash += ip6h->saddr.in6_u.u6_addr32[2] + ip6h->daddr.in6_u.u6_addr32[2];

	cpu_hash += ip6h->saddr.in6_u.u6_addr32[3] + ip6h->daddr.in6_u.u6_addr32[3];

	cpu_hash = SuperFastHash((char *)&cpu_hash, 4, INITVAL + ip6h->nexthdr);



	return cpu_hash;

}



/* Load-Balance traffic based on hashing IP-addrs + L4-proto.  The

 * hashing scheme is symmetric, meaning swapping IP src/dest still hit

 * same CPU.

 */

SEC("xdp")

int  xdp_prognum5_lb_hash_ip_pairs(struct xdp_md *ctx)

{

	void *data_end = (void *)(long)ctx->data_end;

	void *data     = (void *)(long)ctx->data;

	u32 key = bpf_get_smp_processor_id();

	struct ethhdr *eth = data;

	struct datarec *rec;

	u16 eth_proto = 0;

	u64 l3_offset = 0;

	u32 cpu_dest = 0;

	u32 cpu_idx = 0;

	u32 *cpu_lookup;

	u32 key0 = 0;

	u32 *cpu_max;

	u32 cpu_hash;



	rec = bpf_map_lookup_elem(&rx_cnt, &key);

	if (!rec)

		return XDP_PASS;

	NO_TEAR_INC(rec->processed);



	cpu_max = bpf_map_lookup_elem(&cpus_count, &key0);

	if (!cpu_max)

		return XDP_ABORTED;



	if (!(parse_eth(eth, data_end, &eth_proto, &l3_offset)))

		return XDP_PASS; /* Just skip */



	/* Hash for IPv4 and IPv6 */

	switch (eth_proto) {

	case ETH_P_IP:

		cpu_hash = get_ipv4_hash_ip_pair(ctx, l3_offset);

		break;

	case ETH_P_IPV6:

		cpu_hash = get_ipv6_hash_ip_pair(ctx, l3_offset);

		break;

	case ETH_P_ARP: /* ARP packet handled on CPU idx 0 */

	default:

		cpu_hash = 0;

	}



	/* Choose CPU based on hash */

	cpu_idx = cpu_hash % *cpu_max;



	cpu_lookup = bpf_map_lookup_elem(&cpus_available, &cpu_idx);

	if (!cpu_lookup)

		return XDP_ABORTED;

	cpu_dest = *cpu_lookup;



	if (cpu_dest >= nr_cpus) {

		NO_TEAR_INC(rec->issue);

		return XDP_ABORTED;

	}

	return bpf_redirect_map(&cpu_map, cpu_dest, 0);

}



SEC("xdp/cpumap")

int xdp_redirect_cpu_devmap(struct xdp_md *ctx)

{

	void *data_end = (void *)(long)ctx->data_end;

	void *data = (void *)(long)ctx->data;

	struct ethhdr *eth = data;

	u64 nh_off;



	nh_off = sizeof(*eth);

	if (data + nh_off > data_end)

		return XDP_DROP;



	swap_src_dst_mac(data);

	return bpf_redirect_map(&tx_port, 0, 0);

}



SEC("xdp/cpumap")

int xdp_redirect_cpu_pass(struct xdp_md *ctx)

{

	return XDP_PASS;

}



SEC("xdp/cpumap")

int xdp_redirect_cpu_drop(struct xdp_md *ctx)

{

	return XDP_DROP;

}



SEC("xdp/devmap")

int xdp_redirect_egress_prog(struct xdp_md *ctx)

{

	void *data_end = (void *)(long)ctx->data_end;

	void *data = (void *)(long)ctx->data;

	struct ethhdr *eth = data;

	u64 nh_off;



	nh_off = sizeof(*eth);

	if (data + nh_off > data_end)

		return XDP_DROP;



	__builtin_memcpy(eth->h_source, (const char *)tx_mac_addr, ETH_ALEN);



	return XDP_PASS;

}



char _license[] SEC("license") = "GPL";

samples/bpf/xdp_redirect_cpu_user.c

deleted100644 → 0
+0 −559

File deleted.

Preview size limit exceeded, changes collapsed.

samples/bpf/xdp_redirect_map.bpf.c

deleted100644 → 0
+0 −97
Original line number Diff line number Diff line 
/* Copyright (c) 2017 Covalent IO, Inc. http://covalent.io

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of version 2 of the GNU General Public

 * License as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

 * General Public License for more details.

 */

#define KBUILD_MODNAME "foo"



#include "vmlinux.h"

#include "xdp_sample.bpf.h"

#include "xdp_sample_shared.h"



/* The 2nd xdp prog on egress does not support skb mode, so we define two

 * maps, tx_port_general and tx_port_native.

 */

struct {

	__uint(type, BPF_MAP_TYPE_DEVMAP);

	__uint(key_size, sizeof(int));

	__uint(value_size, sizeof(int));

	__uint(max_entries, 1);

} tx_port_general SEC(".maps");



struct {

	__uint(type, BPF_MAP_TYPE_DEVMAP);

	__uint(key_size, sizeof(int));

	__uint(value_size, sizeof(struct bpf_devmap_val));

	__uint(max_entries, 1);

} tx_port_native SEC(".maps");



/* store egress interface mac address */

const volatile __u8 tx_mac_addr[ETH_ALEN];



static __always_inline int xdp_redirect_map(struct xdp_md *ctx, void *redirect_map)

{

	void *data_end = (void *)(long)ctx->data_end;

	void *data = (void *)(long)ctx->data;

	u32 key = bpf_get_smp_processor_id();

	struct ethhdr *eth = data;

	struct datarec *rec;

	u64 nh_off;



	nh_off = sizeof(*eth);

	if (data + nh_off > data_end)

		return XDP_DROP;



	rec = bpf_map_lookup_elem(&rx_cnt, &key);

	if (!rec)

		return XDP_PASS;

	NO_TEAR_INC(rec->processed);

	swap_src_dst_mac(data);

	return bpf_redirect_map(redirect_map, 0, 0);

}



SEC("xdp")

int xdp_redirect_map_general(struct xdp_md *ctx)

{

	return xdp_redirect_map(ctx, &tx_port_general);

}



SEC("xdp")

int xdp_redirect_map_native(struct xdp_md *ctx)

{

	return xdp_redirect_map(ctx, &tx_port_native);

}



SEC("xdp/devmap")

int xdp_redirect_map_egress(struct xdp_md *ctx)

{

	void *data_end = (void *)(long)ctx->data_end;

	void *data = (void *)(long)ctx->data;

	u8 *mac_addr = (u8 *) tx_mac_addr;

	struct ethhdr *eth = data;

	u64 nh_off;



	nh_off = sizeof(*eth);

	if (data + nh_off > data_end)

		return XDP_DROP;



	barrier_var(mac_addr); /* prevent optimizing out memcpy */

	__builtin_memcpy(eth->h_source, mac_addr, ETH_ALEN);



	return XDP_PASS;

}



/* Redirect require an XDP bpf_prog loaded on the TX device */

SEC("xdp")

int xdp_redirect_dummy_prog(struct xdp_md *ctx)

{

	return XDP_PASS;

}



char _license[] SEC("license") = "GPL";