tools/testing/selftests/bpf/progs/bpf_loop.c

// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2021 Facebook */

#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include "bpf_misc.h"

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

struct callback_ctx {
	int output;
};

struct {
	__uint(type, BPF_MAP_TYPE_HASH);
	__uint(max_entries, 32);
	__type(key, int);
	__type(value, int);
} map1 SEC(".maps");

/* These should be set by the user program */
u32 nested_callback_nr_loops;
u32 stop_index = -1;
u32 nr_loops;
int pid;
int callback_selector;

/* Making these global variables so that the userspace program
 * can verify the output through the skeleton
 */
int nr_loops_returned;
int g_output;
int err;

static int callback(__u32 index, void *data)
{
	struct callback_ctx *ctx = data;

	if (index >= stop_index)
		return 1;

	ctx->output += index;

	return 0;
}

static int empty_callback(__u32 index, void *data)
{
	return 0;
}

static int nested_callback2(__u32 index, void *data)
{
	nr_loops_returned += bpf_loop(nested_callback_nr_loops, callback, data, 0);

	return 0;
}

static int nested_callback1(__u32 index, void *data)
{
	bpf_loop(nested_callback_nr_loops, nested_callback2, data, 0);
	return 0;
}

SEC("fentry/" SYS_PREFIX "sys_nanosleep")
int test_prog(void *ctx)
{
	struct callback_ctx data = {};

	if (bpf_get_current_pid_tgid() >> 32 != pid)
		return 0;

	nr_loops_returned = bpf_loop(nr_loops, callback, &data, 0);

	if (nr_loops_returned < 0)
		err = nr_loops_returned;
	else
		g_output = data.output;

	return 0;
}

SEC("fentry/" SYS_PREFIX "sys_nanosleep")
int prog_null_ctx(void *ctx)
{
	if (bpf_get_current_pid_tgid() >> 32 != pid)
		return 0;

	nr_loops_returned = bpf_loop(nr_loops, empty_callback, NULL, 0);

	return 0;
}

SEC("fentry/" SYS_PREFIX "sys_nanosleep")
int prog_invalid_flags(void *ctx)
{
	struct callback_ctx data = {};

	if (bpf_get_current_pid_tgid() >> 32 != pid)
		return 0;

	err = bpf_loop(nr_loops, callback, &data, 1);

	return 0;
}

SEC("fentry/" SYS_PREFIX "sys_nanosleep")
int prog_nested_calls(void *ctx)
{
	struct callback_ctx data = {};

	if (bpf_get_current_pid_tgid() >> 32 != pid)
		return 0;

	nr_loops_returned = 0;
	bpf_loop(nr_loops, nested_callback1, &data, 0);

	g_output = data.output;

	return 0;
}

static int callback_set_f0(int i, void *ctx)
{
	g_output = 0xF0;
	return 0;
}

static int callback_set_0f(int i, void *ctx)
{
	g_output = 0x0F;
	return 0;
}

/*
 * non-constant callback is a corner case for bpf_loop inline logic
 */
SEC("fentry/" SYS_PREFIX "sys_nanosleep")
int prog_non_constant_callback(void *ctx)
{
	struct callback_ctx data = {};

	if (bpf_get_current_pid_tgid() >> 32 != pid)
		return 0;

	int (*callback)(int i, void *ctx);

	g_output = 0;

	if (callback_selector == 0x0F)
		callback = callback_set_0f;
	else
		callback = callback_set_f0;

	bpf_loop(1, callback, NULL, 0);

	return 0;
}

static int stack_check_inner_callback(void *ctx)
{
	return 0;
}

static int map1_lookup_elem(int key)
{
	int *val = bpf_map_lookup_elem(&map1, &key);

	return val ? *val : -1;
}

static void map1_update_elem(int key, int val)
{
	bpf_map_update_elem(&map1, &key, &val, BPF_ANY);
}

static int stack_check_outer_callback(void *ctx)
{
	int a = map1_lookup_elem(1);
	int b = map1_lookup_elem(2);
	int c = map1_lookup_elem(3);
	int d = map1_lookup_elem(4);
	int e = map1_lookup_elem(5);
	int f = map1_lookup_elem(6);

	bpf_loop(1, stack_check_inner_callback, NULL, 0);

	map1_update_elem(1, a + 1);
	map1_update_elem(2, b + 1);
	map1_update_elem(3, c + 1);
	map1_update_elem(4, d + 1);
	map1_update_elem(5, e + 1);
	map1_update_elem(6, f + 1);

	return 0;
}

/* Some of the local variables in stack_check and
 * stack_check_outer_callback would be allocated on stack by
 * compiler. This test should verify that stack content for these
 * variables is preserved between calls to bpf_loop (might be an issue
 * if loop inlining allocates stack slots incorrectly).
 */
SEC("fentry/" SYS_PREFIX "sys_nanosleep")
int stack_check(void *ctx)
{
	if (bpf_get_current_pid_tgid() >> 32 != pid)
		return 0;

	int a = map1_lookup_elem(7);
	int b = map1_lookup_elem(8);
	int c = map1_lookup_elem(9);
	int d = map1_lookup_elem(10);
	int e = map1_lookup_elem(11);
	int f = map1_lookup_elem(12);

	bpf_loop(1, stack_check_outer_callback, NULL, 0);

	map1_update_elem(7,  a + 1);
	map1_update_elem(8, b + 1);
	map1_update_elem(9, c + 1);
	map1_update_elem(10, d + 1);
	map1_update_elem(11, e + 1);
	map1_update_elem(12, f + 1);

	return 0;
}