samples/bpf: Add xdp_sample_pkts example (1e54ad25) · Commits · e / devices / android_kernel_oneplus_sm7250

samples/bpf/Makefile

+4 −0

Original line number	Diff line number	Diff line
		@@ -52,6 +52,7 @@ hostprogs-y += xdp_adjust_tail
		hostprogs-y += xdpsock
		hostprogs-y += xdp_fwd
		hostprogs-y += task_fd_query
		hostprogs-y += xdp_sample_pkts

		# Libbpf dependencies
		LIBBPF = $(TOOLS_PATH)/lib/bpf/libbpf.a
		@@ -107,6 +108,7 @@ xdp_adjust_tail-objs := xdp_adjust_tail_user.o
		xdpsock-objs := bpf_load.o xdpsock_user.o
		xdp_fwd-objs := bpf_load.o xdp_fwd_user.o
		task_fd_query-objs := bpf_load.o task_fd_query_user.o $(TRACE_HELPERS)
		xdp_sample_pkts-objs := xdp_sample_pkts_user.o $(TRACE_HELPERS)

		# Tell kbuild to always build the programs
		always := $(hostprogs-y)
		@@ -163,6 +165,7 @@ always += xdp_adjust_tail_kern.o
		always += xdpsock_kern.o
		always += xdp_fwd_kern.o
		always += task_fd_query_kern.o
		always += xdp_sample_pkts_kern.o

		HOSTCFLAGS += -I$(objtree)/usr/include
		HOSTCFLAGS += -I$(srctree)/tools/lib/
		@@ -179,6 +182,7 @@ HOSTCFLAGS_spintest_user.o += -I$(srctree)/tools/lib/bpf/
		HOSTCFLAGS_trace_event_user.o += -I$(srctree)/tools/lib/bpf/
		HOSTCFLAGS_sampleip_user.o += -I$(srctree)/tools/lib/bpf/
		HOSTCFLAGS_task_fd_query_user.o += -I$(srctree)/tools/lib/bpf/
		HOSTCFLAGS_xdp_sample_pkts_user.o += -I$(srctree)/tools/lib/bpf/

		HOST_LOADLIBES += $(LIBBPF) -lelf
		HOSTLOADLIBES_tracex4 += -lrt

samples/bpf/xdp_sample_pkts_kern.c

0 → 100644

+66 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		#include <linux/ptrace.h>
		#include <linux/version.h>
		#include <uapi/linux/bpf.h>
		#include "bpf_helpers.h"

		#define SAMPLE_SIZE 64ul
		#define MAX_CPUS 128

		#define bpf_printk(fmt, ...) \
		({ \
		char ____fmt[] = fmt; \
		bpf_trace_printk(____fmt, sizeof(____fmt), \
		##__VA_ARGS__); \
		})

		struct bpf_map_def SEC("maps") my_map = {
		.type = BPF_MAP_TYPE_PERF_EVENT_ARRAY,
		.key_size = sizeof(int),
		.value_size = sizeof(u32),
		.max_entries = MAX_CPUS,
		};

		SEC("xdp_sample")
		int xdp_sample_prog(struct xdp_md *ctx)
		{
		void data_end = (void )(long)ctx->data_end;
		void data = (void )(long)ctx->data;

		/* Metadata will be in the perf event before the packet data. */
		struct S {
		u16 cookie;
		u16 pkt_len;
		} __packed metadata;

		if (data < data_end) {
		/* The XDP perf_event_output handler will use the upper 32 bits
		* of the flags argument as a number of bytes to include of the
		* packet payload in the event data. If the size is too big, the
		* call to bpf_perf_event_output will fail and return -EFAULT.
		*
		* See bpf_xdp_event_output in net/core/filter.c.
		*
		* The BPF_F_CURRENT_CPU flag means that the event output fd
		* will be indexed by the CPU number in the event map.
		*/
		u64 flags = BPF_F_CURRENT_CPU;
		u16 sample_size;
		int ret;

		metadata.cookie = 0xdead;
		metadata.pkt_len = (u16)(data_end - data);
		sample_size = min(metadata.pkt_len, SAMPLE_SIZE);
		flags \|= (u64)sample_size << 32;

		ret = bpf_perf_event_output(ctx, &my_map, flags,
		&metadata, sizeof(metadata));
		if (ret)
		bpf_printk("perf_event_output failed: %d\n", ret);
		}

		return XDP_PASS;
		}

		char _license[] SEC("license") = "GPL";
		u32 _version SEC("version") = LINUX_VERSION_CODE;

samples/bpf/xdp_sample_pkts_user.c

0 → 100644

+169 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>
		#include <linux/perf_event.h>
		#include <linux/bpf.h>
		#include <net/if.h>
		#include <errno.h>
		#include <assert.h>
		#include <sys/sysinfo.h>
		#include <sys/ioctl.h>
		#include <signal.h>
		#include <libbpf.h>
		#include <bpf/bpf.h>

		#include "perf-sys.h"
		#include "trace_helpers.h"

		#define MAX_CPUS 128
		static int pmu_fds[MAX_CPUS], if_idx;
		static struct perf_event_mmap_page *headers[MAX_CPUS];
		static char *if_name;

		static int do_attach(int idx, int fd, const char *name)
		{
		int err;

		err = bpf_set_link_xdp_fd(idx, fd, 0);
		if (err < 0)
		printf("ERROR: failed to attach program to %s\n", name);

		return err;
		}

		static int do_detach(int idx, const char *name)
		{
		int err;

		err = bpf_set_link_xdp_fd(idx, -1, 0);
		if (err < 0)
		printf("ERROR: failed to detach program from %s\n", name);

		return err;
		}

		#define SAMPLE_SIZE 64

		static int print_bpf_output(void *data, int size)
		{
		struct {
		__u16 cookie;
		__u16 pkt_len;
		__u8 pkt_data[SAMPLE_SIZE];
		} __packed *e = data;
		int i;

		if (e->cookie != 0xdead) {
		printf("BUG cookie %x sized %d\n",
		e->cookie, size);
		return LIBBPF_PERF_EVENT_ERROR;
		}

		printf("Pkt len: %-5d bytes. Ethernet hdr: ", e->pkt_len);
		for (i = 0; i < 14 && i < e->pkt_len; i++)
		printf("%02x ", e->pkt_data[i]);
		printf("\n");

		return LIBBPF_PERF_EVENT_CONT;
		}

		static void test_bpf_perf_event(int map_fd, int num)
		{
		struct perf_event_attr attr = {
		.sample_type = PERF_SAMPLE_RAW,
		.type = PERF_TYPE_SOFTWARE,
		.config = PERF_COUNT_SW_BPF_OUTPUT,
		.wakeup_events = 1, /* get an fd notification for every event */
		};
		int i;

		for (i = 0; i < num; i++) {
		int key = i;

		pmu_fds[i] = sys_perf_event_open(&attr, -1/pid/, i/cpu/,
		-1/group_fd/, 0);

		assert(pmu_fds[i] >= 0);
		assert(bpf_map_update_elem(map_fd, &key,
		&pmu_fds[i], BPF_ANY) == 0);
		ioctl(pmu_fds[i], PERF_EVENT_IOC_ENABLE, 0);
		}
		}

		static void sig_handler(int signo)
		{
		do_detach(if_idx, if_name);
		exit(0);
		}

		int main(int argc, char **argv)
		{
		struct bpf_prog_load_attr prog_load_attr = {
		.prog_type = BPF_PROG_TYPE_XDP,
		};
		struct bpf_object *obj;
		struct bpf_map *map;
		int prog_fd, map_fd;
		char filename[256];
		int ret, err, i;
		int numcpus;

		if (argc < 2) {
		printf("Usage: %s <ifname>\n", argv[0]);
		return 1;
		}

		numcpus = get_nprocs();
		if (numcpus > MAX_CPUS)
		numcpus = MAX_CPUS;

		snprintf(filename, sizeof(filename), "%s_kern.o", argv[0]);
		prog_load_attr.file = filename;

		if (bpf_prog_load_xattr(&prog_load_attr, &obj, &prog_fd))
		return 1;

		if (!prog_fd) {
		printf("load_bpf_file: %s\n", strerror(errno));
		return 1;
		}

		map = bpf_map__next(NULL, obj);
		if (!map) {
		printf("finding a map in obj file failed\n");
		return 1;
		}
		map_fd = bpf_map__fd(map);

		if_idx = if_nametoindex(argv[1]);
		if (!if_idx)
		if_idx = strtoul(argv[1], NULL, 0);

		if (!if_idx) {
		fprintf(stderr, "Invalid ifname\n");
		return 1;
		}
		if_name = argv[1];
		err = do_attach(if_idx, prog_fd, argv[1]);
		if (err)
		return err;

		if (signal(SIGINT, sig_handler) \|\|
		signal(SIGHUP, sig_handler) \|\|
		signal(SIGTERM, sig_handler)) {
		perror("signal");
		return 1;
		}

		test_bpf_perf_event(map_fd, numcpus);

		for (i = 0; i < numcpus; i++)
		if (perf_event_mmap_header(pmu_fds[i], &headers[i]) < 0)
		return 1;

		ret = perf_event_poller_multi(pmu_fds, headers, numcpus,
		print_bpf_output);
		kill(0, SIGINT);
		return ret;
		}