bpf: mini eBPF library, test stubs and verifier testsuite

obj-y := core.o syscall.o verifier.o

ifdef CONFIG_TEST_BPF

obj-y += test_stub.o

endif

/* Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.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.

 */

#include <linux/kernel.h>

#include <linux/types.h>

#include <linux/slab.h>

#include <linux/err.h>

#include <linux/bpf.h>

/* test stubs for BPF_MAP_TYPE_UNSPEC and for BPF_PROG_TYPE_UNSPEC

 * to be used by user space verifier testsuite

 */

struct bpf_context {

	u64 arg1;

	u64 arg2;

};

static u64 test_func(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5)

{

	return 0;

}

static struct bpf_func_proto test_funcs[] = {

	[BPF_FUNC_unspec] = {

		.func = test_func,

		.gpl_only = true,

		.ret_type = RET_PTR_TO_MAP_VALUE_OR_NULL,

		.arg1_type = ARG_CONST_MAP_PTR,

		.arg2_type = ARG_PTR_TO_MAP_KEY,

	},

};

static const struct bpf_func_proto *test_func_proto(enum bpf_func_id func_id)

{

	if (func_id < 0 || func_id >= ARRAY_SIZE(test_funcs))

		return NULL;

	return &test_funcs[func_id];

}

static const struct bpf_context_access {

	int size;

	enum bpf_access_type type;

} test_ctx_access[] = {

	[offsetof(struct bpf_context, arg1)] = {

		FIELD_SIZEOF(struct bpf_context, arg1),

		BPF_READ

	},

	[offsetof(struct bpf_context, arg2)] = {

		FIELD_SIZEOF(struct bpf_context, arg2),

		BPF_READ

	},

};

static bool test_is_valid_access(int off, int size, enum bpf_access_type type)

{

	const struct bpf_context_access *access;

	if (off < 0 || off >= ARRAY_SIZE(test_ctx_access))

		return false;

	access = &test_ctx_access[off];

	if (access->size == size && (access->type & type))

		return true;

	return false;

}

static struct bpf_verifier_ops test_ops = {

	.get_func_proto = test_func_proto,

	.is_valid_access = test_is_valid_access,

};

static struct bpf_prog_type_list tl_prog = {

	.ops = &test_ops,

	.type = BPF_PROG_TYPE_UNSPEC,

};

static struct bpf_map *test_map_alloc(union bpf_attr *attr)

{

	struct bpf_map *map;

	map = kzalloc(sizeof(*map), GFP_USER);

	if (!map)

		return ERR_PTR(-ENOMEM);

	map->key_size = attr->key_size;

	map->value_size = attr->value_size;

	map->max_entries = attr->max_entries;

	return map;

}

static void test_map_free(struct bpf_map *map)

{

	kfree(map);

}

static struct bpf_map_ops test_map_ops = {

	.map_alloc = test_map_alloc,

	.map_free = test_map_free,

};

static struct bpf_map_type_list tl_map = {

	.ops = &test_map_ops,

	.type = BPF_MAP_TYPE_UNSPEC,

};

static int __init register_test_ops(void)

{

	bpf_register_map_type(&tl_map);

	bpf_register_prog_type(&tl_prog);

	return 0;

}

late_initcall(register_test_ops);

	  against the BPF interpreter or BPF JIT compiler depending on the

	  current setting. This is in particular useful for BPF JIT compiler

	  development, but also to run regression tests against changes in

	  the interpreter code.

	  the interpreter code. It also enables test stubs for eBPF maps and

	  verifier used by user space verifier testsuite.

	  If unsure, say N.

# kbuild trick to avoid linker error. Can be omitted if a module is built.

obj- := dummy.o

# List of programs to build

hostprogs-y := test_verifier

test_verifier-objs := test_verifier.o libbpf.o

# Tell kbuild to always build the programs

always := $(hostprogs-y)

HOSTCFLAGS += -I$(objtree)/usr/include

/* eBPF mini library */

#include <stdlib.h>

#include <stdio.h>

#include <linux/unistd.h>

#include <unistd.h>

#include <string.h>

#include <linux/netlink.h>

#include <linux/bpf.h>

#include <errno.h>

#include "libbpf.h"

static __u64 ptr_to_u64(void *ptr)

{

	return (__u64) (unsigned long) ptr;

}

int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size,

		   int max_entries)

{

	union bpf_attr attr = {

		.map_type = map_type,

		.key_size = key_size,

		.value_size = value_size,

		.max_entries = max_entries

	};

	return syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr));

}

int bpf_update_elem(int fd, void *key, void *value)

{

	union bpf_attr attr = {

		.map_fd = fd,

		.key = ptr_to_u64(key),

		.value = ptr_to_u64(value),

	};

	return syscall(__NR_bpf, BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr));

}

int bpf_lookup_elem(int fd, void *key, void *value)

{

	union bpf_attr attr = {

		.map_fd = fd,

		.key = ptr_to_u64(key),

		.value = ptr_to_u64(value),

	};

	return syscall(__NR_bpf, BPF_MAP_LOOKUP_ELEM, &attr, sizeof(attr));

}

int bpf_delete_elem(int fd, void *key)

{

	union bpf_attr attr = {

		.map_fd = fd,

		.key = ptr_to_u64(key),

	};

	return syscall(__NR_bpf, BPF_MAP_DELETE_ELEM, &attr, sizeof(attr));

}

int bpf_get_next_key(int fd, void *key, void *next_key)

{

	union bpf_attr attr = {

		.map_fd = fd,

		.key = ptr_to_u64(key),

		.next_key = ptr_to_u64(next_key),

	};

	return syscall(__NR_bpf, BPF_MAP_GET_NEXT_KEY, &attr, sizeof(attr));

}

#define ROUND_UP(x, n) (((x) + (n) - 1u) & ~((n) - 1u))

char bpf_log_buf[LOG_BUF_SIZE];

int bpf_prog_load(enum bpf_prog_type prog_type,

		  const struct bpf_insn *insns, int prog_len,

		  const char *license)

{

	union bpf_attr attr = {

		.prog_type = prog_type,

		.insns = ptr_to_u64((void *) insns),

		.insn_cnt = prog_len / sizeof(struct bpf_insn),

		.license = ptr_to_u64((void *) license),

		.log_buf = ptr_to_u64(bpf_log_buf),

		.log_size = LOG_BUF_SIZE,

		.log_level = 1,

	};

	bpf_log_buf[0] = 0;

	return syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr));

}