Commit 7568f4cb authored by Andrey Ignatov's avatar Andrey Ignatov Committed by Alexei Starovoitov
Browse files

selftests/bpf: C based test for sysctl and strtoX 



Add C based test for a few bpf_sysctl_* helpers and bpf_strtoul.

Make sure that sysctl can be identified by name and that multiple
integers can be parsed from sysctl value with bpf_strtoul.

net/ipv4/tcp_mem is chosen as a testing sysctl, it contains 3 unsigned
longs, they all are parsed and compared (val[0] < val[1] < val[2]).

Example of output:
  # ./test_sysctl
  ...
  Test case: C prog: deny all writes .. [PASS]
  Test case: C prog: deny access by name .. [PASS]
  Test case: C prog: read tcp_mem .. [PASS]
  Summary: 39 PASSED, 0 FAILED

Signed-off-by: default avatarAndrey Ignatov <rdna@fb.com>
Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parent 8549ddc8

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

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

// Copyright (c) 2019 Facebook



#include <stdint.h>

#include <string.h>



#include <linux/stddef.h>

#include <linux/bpf.h>



#include "bpf_helpers.h"

#include "bpf_util.h"



/* Max supported length of a string with unsigned long in base 10 (pow2 - 1). */

#define MAX_ULONG_STR_LEN 0xF



/* Max supported length of sysctl value string (pow2). */

#define MAX_VALUE_STR_LEN 0x40



static __always_inline int is_tcp_mem(struct bpf_sysctl *ctx)

{

	char tcp_mem_name[] = "net/ipv4/tcp_mem";

	unsigned char i;

	char name[64];

	int ret;



	memset(name, 0, sizeof(name));

	ret = bpf_sysctl_get_name(ctx, name, sizeof(name), 0);

	if (ret < 0 || ret != sizeof(tcp_mem_name) - 1)

		return 0;



#pragma clang loop unroll(full)

	for (i = 0; i < sizeof(tcp_mem_name); ++i)

		if (name[i] != tcp_mem_name[i])

			return 0;



	return 1;

}



SEC("cgroup/sysctl")

int sysctl_tcp_mem(struct bpf_sysctl *ctx)

{

	unsigned long tcp_mem[3] = {0, 0, 0};

	char value[MAX_VALUE_STR_LEN];

	unsigned char i, off = 0;

	int ret;



	if (ctx->write)

		return 0;



	if (!is_tcp_mem(ctx))

		return 0;



	ret = bpf_sysctl_get_current_value(ctx, value, MAX_VALUE_STR_LEN);

	if (ret < 0 || ret >= MAX_VALUE_STR_LEN)

		return 0;



#pragma clang loop unroll(full)

	for (i = 0; i < ARRAY_SIZE(tcp_mem); ++i) {

		ret = bpf_strtoul(value + off, MAX_ULONG_STR_LEN, 0,

				  tcp_mem + i);

		if (ret <= 0 || ret > MAX_ULONG_STR_LEN)

			return 0;

		off += ret & MAX_ULONG_STR_LEN;

	}





	return tcp_mem[0] < tcp_mem[1] && tcp_mem[1] < tcp_mem[2];

}



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

tools/testing/selftests/bpf/test_sysctl.c

+56 −1
Original line number Diff line number Diff line
@@ -11,6 +11,7 @@ 
#include <linux/filter.h>



#include <bpf/bpf.h>

#include <bpf/libbpf.h>



#include "bpf_rlimit.h"

#include "bpf_util.h"
@@ -26,6 +27,7 @@ struct sysctl_test { 
	const char *descr;

	size_t fixup_value_insn;

	struct bpf_insn	insns[MAX_INSNS];

	const char *prog_file;

	enum bpf_attach_type attach_type;

	const char *sysctl;

	int open_flags;
@@ -1302,6 +1304,31 @@ static struct sysctl_test tests[] = { 
		.open_flags = O_RDONLY,

		.result = SUCCESS,

	},

	{

		"C prog: deny all writes",

		.prog_file = "./test_sysctl_prog.o",

		.attach_type = BPF_CGROUP_SYSCTL,

		.sysctl = "net/ipv4/tcp_mem",

		.open_flags = O_WRONLY,

		.newval = "123 456 789",

		.result = OP_EPERM,

	},

	{

		"C prog: deny access by name",

		.prog_file = "./test_sysctl_prog.o",

		.attach_type = BPF_CGROUP_SYSCTL,

		.sysctl = "net/ipv4/route/mtu_expires",

		.open_flags = O_RDONLY,

		.result = OP_EPERM,

	},

	{

		"C prog: read tcp_mem",

		.prog_file = "./test_sysctl_prog.o",

		.attach_type = BPF_CGROUP_SYSCTL,

		.sysctl = "net/ipv4/tcp_mem",

		.open_flags = O_RDONLY,

		.result = SUCCESS,

	},

};



static size_t probe_prog_length(const struct bpf_insn *fp)
@@ -1335,7 +1362,8 @@ static int fixup_sysctl_value(const char *buf, size_t buf_len, 
	return 0;

}



static int load_sysctl_prog(struct sysctl_test *test, const char *sysctl_path)

static int load_sysctl_prog_insns(struct sysctl_test *test,

				  const char *sysctl_path)

{

	struct bpf_insn *prog = test->insns;

	struct bpf_load_program_attr attr;
@@ -1377,6 +1405,33 @@ static int load_sysctl_prog(struct sysctl_test *test, const char *sysctl_path) 
	return ret;

}



static int load_sysctl_prog_file(struct sysctl_test *test)

{

	struct bpf_prog_load_attr attr;

	struct bpf_object *obj;

	int prog_fd;



	memset(&attr, 0, sizeof(struct bpf_prog_load_attr));

	attr.file = test->prog_file;

	attr.prog_type = BPF_PROG_TYPE_CGROUP_SYSCTL;



	if (bpf_prog_load_xattr(&attr, &obj, &prog_fd)) {

		if (test->result != LOAD_REJECT)

			log_err(">>> Loading program (%s) error.\n",

				test->prog_file);

		return -1;

	}



	return prog_fd;

}



static int load_sysctl_prog(struct sysctl_test *test, const char *sysctl_path)

{

		return test->prog_file

			? load_sysctl_prog_file(test)

			: load_sysctl_prog_insns(test, sysctl_path);

}



static int access_sysctl(const char *sysctl_path,

			 const struct sysctl_test *test)

{

CRA Git | Maintained and supported by SUSTech CRA and CCSE