samples/bpf: remove obsolete cgroup related tests (5ea68f04) · Commits · git / linux-net

samples/bpf/Makefile

+0 −9

Original line number	Diff line number	Diff line
		@@ -25,10 +25,7 @@ tprogs-y += offwaketime
		tprogs-y += spintest
		tprogs-y += map_perf_test
		tprogs-y += test_overhead
		tprogs-y += test_cgrp2_array_pin
		tprogs-y += test_cgrp2_attach
		tprogs-y += xdp_router_ipv4
		tprogs-y += test_current_task_under_cgroup
		tprogs-y += trace_event
		tprogs-y += sampleip
		tprogs-y += tc_l2_redirect
		@@ -72,10 +69,6 @@ offwaketime-objs := offwaketime_user.o $(TRACE_HELPERS)
		spintest-objs := spintest_user.o $(TRACE_HELPERS)
		map_perf_test-objs := map_perf_test_user.o
		test_overhead-objs := test_overhead_user.o
		test_cgrp2_array_pin-objs := test_cgrp2_array_pin.o
		test_cgrp2_attach-objs := test_cgrp2_attach.o
		test_current_task_under_cgroup-objs := $(CGROUP_HELPERS) \
		test_current_task_under_cgroup_user.o
		trace_event-objs := trace_event_user.o $(TRACE_HELPERS)
		sampleip-objs := sampleip_user.o $(TRACE_HELPERS)
		tc_l2_redirect-objs := tc_l2_redirect_user.o
		@@ -116,8 +109,6 @@ always-y += test_overhead_tp.bpf.o
		always-y += test_overhead_raw_tp.bpf.o
		always-y += test_overhead_kprobe.bpf.o
		always-y += parse_varlen.o parse_simple.o parse_ldabs.o
		always-y += test_cgrp2_tc.bpf.o
		always-y += test_current_task_under_cgroup.bpf.o
		always-y += trace_event_kern.o
		always-y += sampleip_kern.o
		always-y += lwt_len_hist.bpf.o

samples/bpf/test_cgrp2_array_pin.c

deleted100644 → 0

+0 −106

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-only
		/* Copyright (c) 2016 Facebook
		*/
		#include <linux/unistd.h>
		#include <linux/bpf.h>

		#include <stdio.h>
		#include <stdint.h>
		#include <unistd.h>
		#include <string.h>
		#include <errno.h>
		#include <fcntl.h>

		#include <bpf/bpf.h>

		static void usage(void)
		{
		printf("Usage: test_cgrp2_array_pin [...]\n");
		printf(" -F <file> File to pin an BPF cgroup array\n");
		printf(" -U <file> Update an already pinned BPF cgroup array\n");
		printf(" -v <value> Full path of the cgroup2\n");
		printf(" -h Display this help\n");
		}

		int main(int argc, char **argv)
		{
		const char pinned_file = NULL, cg2 = NULL;
		int create_array = 1;
		int array_key = 0;
		int array_fd = -1;
		int cg2_fd = -1;
		int ret = -1;
		int opt;

		while ((opt = getopt(argc, argv, "F:U:v:")) != -1) {
		switch (opt) {
		/* General args */
		case 'F':
		pinned_file = optarg;
		break;
		case 'U':
		pinned_file = optarg;
		create_array = 0;
		break;
		case 'v':
		cg2 = optarg;
		break;
		default:
		usage();
		goto out;
		}
		}

		if (!cg2 \|\| !pinned_file) {
		usage();
		goto out;
		}

		cg2_fd = open(cg2, O_RDONLY);
		if (cg2_fd < 0) {
		fprintf(stderr, "open(%s,...): %s(%d)\n",
		cg2, strerror(errno), errno);
		goto out;
		}

		if (create_array) {
		array_fd = bpf_map_create(BPF_MAP_TYPE_CGROUP_ARRAY, NULL,
		sizeof(uint32_t), sizeof(uint32_t),
		1, NULL);
		if (array_fd < 0) {
		fprintf(stderr,
		"bpf_create_map(BPF_MAP_TYPE_CGROUP_ARRAY,...): %s(%d)\n",
		strerror(errno), errno);
		goto out;
		}
		} else {
		array_fd = bpf_obj_get(pinned_file);
		if (array_fd < 0) {
		fprintf(stderr, "bpf_obj_get(%s): %s(%d)\n",
		pinned_file, strerror(errno), errno);
		goto out;
		}
		}

		ret = bpf_map_update_elem(array_fd, &array_key, &cg2_fd, 0);
		if (ret) {
		perror("bpf_map_update_elem");
		goto out;
		}

		if (create_array) {
		ret = bpf_obj_pin(array_fd, pinned_file);
		if (ret) {
		fprintf(stderr, "bpf_obj_pin(..., %s): %s(%d)\n",
		pinned_file, strerror(errno), errno);
		goto out;
		}
		}

		out:
		if (array_fd != -1)
		close(array_fd);
		if (cg2_fd != -1)
		close(cg2_fd);
		return ret;
		}

samples/bpf/test_cgrp2_attach.c

deleted100644 → 0

+0 −177

Original line number	Diff line number	Diff line
		/* eBPF example program:
		*
		* - Creates arraymap in kernel with 4 bytes keys and 8 byte values
		*
		* - Loads eBPF program
		*
		* The eBPF program accesses the map passed in to store two pieces of
		* information. The number of invocations of the program, which maps
		* to the number of packets received, is stored to key 0. Key 1 is
		* incremented on each iteration by the number of bytes stored in
		* the skb.
		*
		* - Attaches the new program to a cgroup using BPF_PROG_ATTACH
		*
		* - Every second, reads map[0] and map[1] to see how many bytes and
		* packets were seen on any socket of tasks in the given cgroup.
		*/

		#define _GNU_SOURCE

		#include <stdio.h>
		#include <stdlib.h>
		#include <stddef.h>
		#include <string.h>
		#include <unistd.h>
		#include <assert.h>
		#include <errno.h>
		#include <fcntl.h>

		#include <linux/bpf.h>
		#include <bpf/bpf.h>

		#include "bpf_insn.h"
		#include "bpf_util.h"

		enum {
		MAP_KEY_PACKETS,
		MAP_KEY_BYTES,
		};

		char bpf_log_buf[BPF_LOG_BUF_SIZE];

		static int prog_load(int map_fd, int verdict)
		{
		struct bpf_insn prog[] = {
		BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), /* save r6 so it's not clobbered by BPF_CALL */

		/* Count packets */
		BPF_MOV64_IMM(BPF_REG_0, MAP_KEY_PACKETS), /* r0 = 0 */
		BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_0, -4), /* (u32 )(fp - 4) = r0 */
		BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
		BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 = fp - 4 */
		BPF_LD_MAP_FD(BPF_REG_1, map_fd), /* load map fd to r1 */
		BPF_RAW_INSN(BPF_JMP \| BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
		BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2),
		BPF_MOV64_IMM(BPF_REG_1, 1), /* r1 = 1 */
		BPF_ATOMIC_OP(BPF_DW, BPF_ADD, BPF_REG_0, BPF_REG_1, 0),

		/* Count bytes */
		BPF_MOV64_IMM(BPF_REG_0, MAP_KEY_BYTES), /* r0 = 1 */
		BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_0, -4), /* (u32 )(fp - 4) = r0 */
		BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
		BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 = fp - 4 */
		BPF_LD_MAP_FD(BPF_REG_1, map_fd),
		BPF_RAW_INSN(BPF_JMP \| BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
		BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2),
		BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_6, offsetof(struct __sk_buff, len)), /* r1 = skb->len */

		BPF_ATOMIC_OP(BPF_DW, BPF_ADD, BPF_REG_0, BPF_REG_1, 0),

		BPF_MOV64_IMM(BPF_REG_0, verdict), /* r0 = verdict */
		BPF_EXIT_INSN(),
		};
		size_t insns_cnt = ARRAY_SIZE(prog);
		LIBBPF_OPTS(bpf_prog_load_opts, opts,
		.log_buf = bpf_log_buf,
		.log_size = BPF_LOG_BUF_SIZE,
		);

		return bpf_prog_load(BPF_PROG_TYPE_CGROUP_SKB, NULL, "GPL",
		prog, insns_cnt, &opts);
		}

		static int usage(const char *argv0)
		{
		printf("Usage: %s [-d] [-D] <cg-path> <egress\|ingress>\n", argv0);
		printf(" -d Drop Traffic\n");
		printf(" -D Detach filter, and exit\n");
		return EXIT_FAILURE;
		}

		static int attach_filter(int cg_fd, int type, int verdict)
		{
		int prog_fd, map_fd, ret, key;
		long long pkt_cnt, byte_cnt;

		map_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, NULL,
		sizeof(key), sizeof(byte_cnt),
		256, NULL);
		if (map_fd < 0) {
		printf("Failed to create map: '%s'\n", strerror(errno));
		return EXIT_FAILURE;
		}

		prog_fd = prog_load(map_fd, verdict);
		printf("Output from kernel verifier:\n%s\n-------\n", bpf_log_buf);

		if (prog_fd < 0) {
		printf("Failed to load prog: '%s'\n", strerror(errno));
		return EXIT_FAILURE;
		}

		ret = bpf_prog_attach(prog_fd, cg_fd, type, 0);
		if (ret < 0) {
		printf("Failed to attach prog to cgroup: '%s'\n",
		strerror(errno));
		return EXIT_FAILURE;
		}
		while (1) {
		key = MAP_KEY_PACKETS;
		assert(bpf_map_lookup_elem(map_fd, &key, &pkt_cnt) == 0);

		key = MAP_KEY_BYTES;
		assert(bpf_map_lookup_elem(map_fd, &key, &byte_cnt) == 0);

		printf("cgroup received %lld packets, %lld bytes\n",
		pkt_cnt, byte_cnt);
		sleep(1);
		}

		return EXIT_SUCCESS;
		}

		int main(int argc, char **argv)
		{
		int detach_only = 0, verdict = 1;
		enum bpf_attach_type type;
		int opt, cg_fd, ret;

		while ((opt = getopt(argc, argv, "Dd")) != -1) {
		switch (opt) {
		case 'd':
		verdict = 0;
		break;
		case 'D':
		detach_only = 1;
		break;
		default:
		return usage(argv[0]);
		}
		}

		if (argc - optind < 2)
		return usage(argv[0]);

		if (strcmp(argv[optind + 1], "ingress") == 0)
		type = BPF_CGROUP_INET_INGRESS;
		else if (strcmp(argv[optind + 1], "egress") == 0)
		type = BPF_CGROUP_INET_EGRESS;
		else
		return usage(argv[0]);

		cg_fd = open(argv[optind], O_DIRECTORY \| O_RDONLY);
		if (cg_fd < 0) {
		printf("Failed to open cgroup path: '%s'\n", strerror(errno));
		return EXIT_FAILURE;
		}

		if (detach_only) {
		ret = bpf_prog_detach(cg_fd, type);
		printf("bpf_prog_detach() returned '%s' (%d)\n",
		strerror(errno), errno);
		} else
		ret = attach_filter(cg_fd, type, verdict);

		return ret;
		}

samples/bpf/test_cgrp2_tc.bpf.c

deleted100644 → 0

+0 −56

Original line number	Diff line number	Diff line
		/* Copyright (c) 2016 Facebook
		*
		* 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.
		*/
		#define KBUILD_MODNAME "foo"
		#include "vmlinux.h"
		#include "net_shared.h"
		#include <bpf/bpf_helpers.h>

		/* copy of 'struct ethhdr' without __packed */
		struct eth_hdr {
		unsigned char h_dest[ETH_ALEN];
		unsigned char h_source[ETH_ALEN];
		unsigned short h_proto;
		};

		struct {
		__uint(type, BPF_MAP_TYPE_CGROUP_ARRAY);
		__type(key, u32);
		__type(value, u32);
		__uint(pinning, LIBBPF_PIN_BY_NAME);
		__uint(max_entries, 1);
		} test_cgrp2_array_pin SEC(".maps");

		SEC("filter")
		int handle_egress(struct __sk_buff *skb)
		{
		void data = (void )(long)skb->data;
		struct eth_hdr *eth = data;
		struct ipv6hdr ip6h = data + sizeof(eth);
		void data_end = (void )(long)skb->data_end;
		char dont_care_msg[] = "dont care %04x %d\n";
		char pass_msg[] = "pass\n";
		char reject_msg[] = "reject\n";

		/* single length check */
		if (data + sizeof(eth) + sizeof(ip6h) > data_end)
		return TC_ACT_OK;

		if (eth->h_proto != bpf_htons(ETH_P_IPV6) \|\|
		ip6h->nexthdr != IPPROTO_ICMPV6) {
		bpf_trace_printk(dont_care_msg, sizeof(dont_care_msg),
		eth->h_proto, ip6h->nexthdr);
		return TC_ACT_OK;
		} else if (bpf_skb_under_cgroup(skb, &test_cgrp2_array_pin, 0) != 1) {
		bpf_trace_printk(pass_msg, sizeof(pass_msg));
		return TC_ACT_OK;
		} else {
		bpf_trace_printk(reject_msg, sizeof(reject_msg));
		return TC_ACT_SHOT;
		}
		}

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

samples/bpf/test_cgrp2_tc.sh

deleted100755 → 0

+0 −187

Original line number	Diff line number	Diff line
		#!/bin/bash
		# SPDX-License-Identifier: GPL-2.0

		MY_DIR=$(dirname $0)
		# Details on the bpf prog
		BPF_CGRP2_ARRAY_NAME='test_cgrp2_array_pin'
		BPF_PROG="$MY_DIR/test_cgrp2_tc.bpf.o"
		BPF_SECTION='filter'

		[ -z "$TC" ] && TC='tc'
		[ -z "$IP" ] && IP='ip'

		# Names of the veth interface, net namespace...etc.
		HOST_IFC='ve'
		NS_IFC='vens'
		NS='ns'

		find_mnt() {
		cat /proc/mounts \| \
		awk '{ if ($3 == "'$1'" && mnt == "") { mnt = $2 }} END { print mnt }'
		}

		# Init cgroup2 vars
		init_cgrp2_vars() {
		CGRP2_ROOT=$(find_mnt cgroup2)
		if [ -z "$CGRP2_ROOT" ]
		then
		CGRP2_ROOT='/mnt/cgroup2'
		MOUNT_CGRP2="yes"
		fi
		CGRP2_TC="$CGRP2_ROOT/tc"
		CGRP2_TC_LEAF="$CGRP2_TC/leaf"
		}

		# Init bpf fs vars
		init_bpf_fs_vars() {
		local bpf_fs_root=$(find_mnt bpf)
		[ -n "$bpf_fs_root" ] \|\| return -1
		BPF_FS_TC_SHARE="$bpf_fs_root/tc/globals"
		}

		setup_cgrp2() {
		case $1 in
		start)
		if [ "$MOUNT_CGRP2" == 'yes' ]
		then
		[ -d $CGRP2_ROOT ] \|\| mkdir -p $CGRP2_ROOT
		mount -t cgroup2 none $CGRP2_ROOT \|\| return $?
		fi
		mkdir -p $CGRP2_TC_LEAF
		;;
		*)
		rmdir $CGRP2_TC_LEAF && rmdir $CGRP2_TC
		[ "$MOUNT_CGRP2" == 'yes' ] && umount $CGRP2_ROOT
		;;
		esac
		}

		setup_bpf_cgrp2_array() {
		local bpf_cgrp2_array="$BPF_FS_TC_SHARE/$BPF_CGRP2_ARRAY_NAME"
		case $1 in
		start)
		$MY_DIR/test_cgrp2_array_pin -U $bpf_cgrp2_array -v $CGRP2_TC
		;;
		*)
		[ -d "$BPF_FS_TC_SHARE" ] && rm -f $bpf_cgrp2_array
		;;
		esac
		}

		setup_net() {
		case $1 in
		start)
		$IP link add $HOST_IFC type veth peer name $NS_IFC \|\| return $?
		$IP link set dev $HOST_IFC up \|\| return $?
		sysctl -q net.ipv6.conf.$HOST_IFC.disable_ipv6=0
		sysctl -q net.ipv6.conf.$HOST_IFC.accept_dad=0

		$IP netns add $NS \|\| return $?
		$IP link set dev $NS_IFC netns $NS \|\| return $?
		$IP -n $NS link set dev $NS_IFC up \|\| return $?
		$IP netns exec $NS sysctl -q net.ipv6.conf.$NS_IFC.disable_ipv6=0
		$IP netns exec $NS sysctl -q net.ipv6.conf.$NS_IFC.accept_dad=0
		$TC qdisc add dev $HOST_IFC clsact \|\| return $?
		$TC filter add dev $HOST_IFC egress bpf da obj $BPF_PROG sec $BPF_SECTION \|\| return $?
		;;
		*)
		$IP netns del $NS
		$IP link del $HOST_IFC
		;;
		esac
		}

		run_in_cgrp() {
		# Fork another bash and move it under the specified cgroup.
		# It makes the cgroup cleanup easier at the end of the test.
		cmd='echo $$ > '
		cmd="$cmd $1/cgroup.procs; exec $2"
		bash -c "$cmd"
		}

		do_test() {
		run_in_cgrp $CGRP2_TC_LEAF "ping -6 -c3 ff02::1%$HOST_IFC >& /dev/null"
		local dropped=$($TC -s qdisc show dev $HOST_IFC \| tail -3 \| \
		awk '/drop/{print substr($7, 0, index($7, ",")-1)}')
		if [[ $dropped -eq 0 ]]
		then
		echo "FAIL"
		return 1
		else
		echo "Successfully filtered $dropped packets"
		return 0
		fi
		}

		do_exit() {
		if [ "$DEBUG" == "yes" ] && [ "$MODE" != 'cleanuponly' ]
		then
		echo "------ DEBUG ------"
		echo "mount: "; mount \| grep -E '(cgroup2\|bpf)'; echo
		echo "$CGRP2_TC_LEAF: "; ls -l $CGRP2_TC_LEAF; echo
		if [ -d "$BPF_FS_TC_SHARE" ]
		then
		echo "$BPF_FS_TC_SHARE: "; ls -l $BPF_FS_TC_SHARE; echo
		fi
		echo "Host net:"
		$IP netns
		$IP link show dev $HOST_IFC
		$IP -6 a show dev $HOST_IFC
		$TC -s qdisc show dev $HOST_IFC
		echo
		echo "$NS net:"
		$IP -n $NS link show dev $NS_IFC
		$IP -n $NS -6 link show dev $NS_IFC
		echo "------ DEBUG ------"
		echo
		fi

		if [ "$MODE" != 'nocleanup' ]
		then
		setup_net stop
		setup_bpf_cgrp2_array stop
		setup_cgrp2 stop
		fi
		}

		init_cgrp2_vars
		init_bpf_fs_vars

		while [[ $# -ge 1 ]]
		do
		a="$1"
		case $a in
		debug)
		DEBUG='yes'
		shift 1
		;;
		cleanup-only)
		MODE='cleanuponly'
		shift 1
		;;
		no-cleanup)
		MODE='nocleanup'
		shift 1
		;;
		*)
		echo "test_cgrp2_tc [debug] [cleanup-only \| no-cleanup]"
		echo " debug: Print cgrp and network setup details at the end of the test"
		echo " cleanup-only: Try to cleanup things from last test. No test will be run"
		echo " no-cleanup: Run the test but don't do cleanup at the end"
		echo "[Note: If no arg is given, it will run the test and do cleanup at the end]"
		echo
		exit -1
		;;
		esac
		done

		trap do_exit 0

		[ "$MODE" == 'cleanuponly' ] && exit

		setup_cgrp2 start \|\| exit $?
		setup_net start \|\| exit $?
		init_bpf_fs_vars \|\| exit $?
		setup_bpf_cgrp2_array start \|\| exit $?
		do_test
		echo