Commit fb30d4b7 authored by Martin KaFai Lau's avatar Martin KaFai Lau Committed by David S. Miller
Browse files

bpf: Add tests for map-in-map 



Test cases for array of maps and hash of maps.

Signed-off-by: default avatarMartin KaFai Lau <kafai@fb.com>
Acked-by: default avatarAlexei Starovoitov <ast@kernel.org>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent bcc6b1b7

samples/bpf/Makefile

+4 −0
Original line number Original line Diff line number Diff line
@@ -34,6 +34,7 @@ hostprogs-y += sampleip 
hostprogs-y += tc_l2_redirect

hostprogs-y += tc_l2_redirect

hostprogs-y += lwt_len_hist

hostprogs-y += lwt_len_hist

hostprogs-y += xdp_tx_iptunnel

hostprogs-y += xdp_tx_iptunnel

hostprogs-y += test_map_in_map





# Libbpf dependencies

# Libbpf dependencies

LIBBPF := ../../tools/lib/bpf/bpf.o

LIBBPF := ../../tools/lib/bpf/bpf.o
@@ -72,6 +73,7 @@ sampleip-objs := bpf_load.o $(LIBBPF) sampleip_user.o 
tc_l2_redirect-objs := bpf_load.o $(LIBBPF) tc_l2_redirect_user.o

tc_l2_redirect-objs := bpf_load.o $(LIBBPF) tc_l2_redirect_user.o

lwt_len_hist-objs := bpf_load.o $(LIBBPF) lwt_len_hist_user.o

lwt_len_hist-objs := bpf_load.o $(LIBBPF) lwt_len_hist_user.o

xdp_tx_iptunnel-objs := bpf_load.o $(LIBBPF) xdp_tx_iptunnel_user.o

xdp_tx_iptunnel-objs := bpf_load.o $(LIBBPF) xdp_tx_iptunnel_user.o

test_map_in_map-objs := bpf_load.o $(LIBBPF) test_map_in_map_user.o





# Tell kbuild to always build the programs

# Tell kbuild to always build the programs

always := $(hostprogs-y)

always := $(hostprogs-y)
@@ -105,6 +107,7 @@ always += trace_event_kern.o 
always += sampleip_kern.o

always += sampleip_kern.o

always += lwt_len_hist_kern.o

always += lwt_len_hist_kern.o

always += xdp_tx_iptunnel_kern.o

always += xdp_tx_iptunnel_kern.o

always += test_map_in_map_kern.o





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

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

HOSTCFLAGS += -I$(srctree)/tools/lib/

HOSTCFLAGS += -I$(srctree)/tools/lib/
@@ -139,6 +142,7 @@ HOSTLOADLIBES_sampleip += -lelf 
HOSTLOADLIBES_tc_l2_redirect += -l elf

HOSTLOADLIBES_tc_l2_redirect += -l elf

HOSTLOADLIBES_lwt_len_hist += -l elf

HOSTLOADLIBES_lwt_len_hist += -l elf

HOSTLOADLIBES_xdp_tx_iptunnel += -lelf

HOSTLOADLIBES_xdp_tx_iptunnel += -lelf

HOSTLOADLIBES_test_map_in_map += -lelf





# Allows pointing LLC/CLANG to a LLVM backend with bpf support, redefine on cmdline:

# Allows pointing LLC/CLANG to a LLVM backend with bpf support, redefine on cmdline:

#  make samples/bpf/ LLC=~/git/llvm/build/bin/llc CLANG=~/git/llvm/build/bin/clang

#  make samples/bpf/ LLC=~/git/llvm/build/bin/llc CLANG=~/git/llvm/build/bin/clang

samples/bpf/bpf_helpers.h

+1 −0
Original line number Original line Diff line number Diff line
@@ -80,6 +80,7 @@ struct bpf_map_def { 
	unsigned int value_size;

	unsigned int value_size;

	unsigned int max_entries;

	unsigned int max_entries;

	unsigned int map_flags;

	unsigned int map_flags;

	unsigned int inner_map_idx;

};

};





static int (*bpf_skb_load_bytes)(void *ctx, int off, void *to, int len) =

static int (*bpf_skb_load_bytes)(void *ctx, int off, void *to, int len) =

samples/bpf/bpf_load.c

+17 −5
Original line number Original line Diff line number Diff line
@@ -43,6 +43,7 @@ struct bpf_map_def { 
	unsigned int value_size;

	unsigned int value_size;

	unsigned int max_entries;

	unsigned int max_entries;

	unsigned int map_flags;

	unsigned int map_flags;

	unsigned int inner_map_idx;

};

};





static int populate_prog_array(const char *event, int prog_fd)

static int populate_prog_array(const char *event, int prog_fd)
@@ -198,11 +199,22 @@ static int load_maps(struct bpf_map_def *maps, int len) 




	for (i = 0; i < len / sizeof(struct bpf_map_def); i++) {

	for (i = 0; i < len / sizeof(struct bpf_map_def); i++) {





		if (maps[i].type == BPF_MAP_TYPE_ARRAY_OF_MAPS ||

		    maps[i].type == BPF_MAP_TYPE_HASH_OF_MAPS) {

			int inner_map_fd = map_fd[maps[i].inner_map_idx];



			map_fd[i] = bpf_create_map_in_map(maps[i].type,

							  maps[i].key_size,

							  inner_map_fd,

							  maps[i].max_entries,

							  maps[i].map_flags);

		} else {

			map_fd[i] = bpf_create_map(maps[i].type,

			map_fd[i] = bpf_create_map(maps[i].type,

						   maps[i].key_size,

						   maps[i].key_size,

						   maps[i].value_size,

						   maps[i].value_size,

						   maps[i].max_entries,

						   maps[i].max_entries,

						   maps[i].map_flags);

						   maps[i].map_flags);

		}

		if (map_fd[i] < 0) {

		if (map_fd[i] < 0) {

			printf("failed to create a map: %d %s\n",

			printf("failed to create a map: %d %s\n",

			       errno, strerror(errno));

			       errno, strerror(errno));

samples/bpf/test_map_in_map_kern.c

0 → 100644
+173 −0
Original line number Original line Diff line number Diff line 
/*

 * Copyright (c) 2017 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 <linux/ptrace.h>

#include <linux/version.h>

#include <uapi/linux/bpf.h>

#include <uapi/linux/in6.h>

#include "bpf_helpers.h"



#define MAX_NR_PORTS 65536



/* map #0 */

struct bpf_map_def SEC("maps") port_a = {

	.type = BPF_MAP_TYPE_ARRAY,

	.key_size = sizeof(u32),

	.value_size = sizeof(int),

	.max_entries = MAX_NR_PORTS,

};



/* map #1 */

struct bpf_map_def SEC("maps") port_h = {

	.type = BPF_MAP_TYPE_HASH,

	.key_size = sizeof(u32),

	.value_size = sizeof(int),

	.max_entries = 1,

};



/* map #2 */

struct bpf_map_def SEC("maps") reg_result_h = {

	.type = BPF_MAP_TYPE_HASH,

	.key_size = sizeof(u32),

	.value_size = sizeof(int),

	.max_entries = 1,

};



/* map #3 */

struct bpf_map_def SEC("maps") inline_result_h = {

	.type = BPF_MAP_TYPE_HASH,

	.key_size = sizeof(u32),

	.value_size = sizeof(int),

	.max_entries = 1,

};



/* map #4 */ /* Test case #0 */

struct bpf_map_def SEC("maps") a_of_port_a = {

	.type = BPF_MAP_TYPE_ARRAY_OF_MAPS,

	.key_size = sizeof(u32),

	.inner_map_idx = 0, /* map_fd[0] is port_a */

	.max_entries = MAX_NR_PORTS,

};



/* map #5 */ /* Test case #1 */

struct bpf_map_def SEC("maps") h_of_port_a = {

	.type = BPF_MAP_TYPE_HASH_OF_MAPS,

	.key_size = sizeof(u32),

	.inner_map_idx = 0, /* map_fd[0] is port_a */

	.max_entries = 1,

};



/* map #6 */ /* Test case #2 */

struct bpf_map_def SEC("maps") h_of_port_h = {

	.type = BPF_MAP_TYPE_HASH_OF_MAPS,

	.key_size = sizeof(u32),

	.inner_map_idx = 1, /* map_fd[1] is port_h */

	.max_entries = 1,

};



static __always_inline int do_reg_lookup(void *inner_map, u32 port)

{

	int *result;



	result = bpf_map_lookup_elem(inner_map, &port);

	return result ? *result : -ENOENT;

}



static __always_inline int do_inline_array_lookup(void *inner_map, u32 port)

{

	int *result;



	if (inner_map != &port_a)

		return -EINVAL;



	result = bpf_map_lookup_elem(&port_a, &port);

	return result ? *result : -ENOENT;

}



static __always_inline int do_inline_hash_lookup(void *inner_map, u32 port)

{

	int *result;



	if (inner_map != &port_h)

		return -EINVAL;



	result = bpf_map_lookup_elem(&port_h, &port);

	return result ? *result : -ENOENT;

}



SEC("kprobe/sys_connect")

int trace_sys_connect(struct pt_regs *ctx)

{

	struct sockaddr_in6 *in6;

	u16 test_case, port, dst6[8];

	int addrlen, ret, inline_ret, ret_key = 0;

	u32 port_key;

	void *outer_map, *inner_map;

	bool inline_hash = false;



	in6 = (struct sockaddr_in6 *)PT_REGS_PARM2(ctx);

	addrlen = (int)PT_REGS_PARM3(ctx);



	if (addrlen != sizeof(*in6))

		return 0;



	ret = bpf_probe_read(dst6, sizeof(dst6), &in6->sin6_addr);

	if (ret) {

		inline_ret = ret;

		goto done;

	}



	if (dst6[0] != 0xdead || dst6[1] != 0xbeef)

		return 0;



	test_case = dst6[7];



	ret = bpf_probe_read(&port, sizeof(port), &in6->sin6_port);

	if (ret) {

		inline_ret = ret;

		goto done;

	}



	port_key = port;



	ret = -ENOENT;

	if (test_case == 0) {

		outer_map = &a_of_port_a;

	} else if (test_case == 1) {

		outer_map = &h_of_port_a;

	} else if (test_case == 2) {

		outer_map = &h_of_port_h;

	} else {

		ret = __LINE__;

		inline_ret = ret;

		goto done;

	}



	inner_map = bpf_map_lookup_elem(outer_map, &port_key);

	if (!inner_map) {

		ret = __LINE__;

		inline_ret = ret;

		goto done;

	}



	ret = do_reg_lookup(inner_map, port_key);



	if (test_case == 0 || test_case == 1)

		inline_ret = do_inline_array_lookup(inner_map, port_key);

	else

		inline_ret = do_inline_hash_lookup(inner_map, port_key);



done:

	bpf_map_update_elem(&reg_result_h, &ret_key, &ret, BPF_ANY);

	bpf_map_update_elem(&inline_result_h, &ret_key, &inline_ret, BPF_ANY);



	return 0;

}



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

u32 _version SEC("version") = LINUX_VERSION_CODE;

samples/bpf/test_map_in_map_user.c

0 → 100644
+116 −0
Original line number Original line Diff line number Diff line 
/*

 * Copyright (c) 2017 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.

 */

#include <sys/resource.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#include <stdint.h>

#include <assert.h>

#include <errno.h>

#include <stdlib.h>

#include <stdio.h>

#include "libbpf.h"

#include "bpf_load.h"



#define PORT_A		(map_fd[0])

#define PORT_H		(map_fd[1])

#define REG_RESULT_H	(map_fd[2])

#define INLINE_RESULT_H	(map_fd[3])

#define A_OF_PORT_A	(map_fd[4]) /* Test case #0 */

#define H_OF_PORT_A	(map_fd[5]) /* Test case #1 */

#define H_OF_PORT_H	(map_fd[6]) /* Test case #2 */



static const char * const test_names[] = {

	"Array of Array",

	"Hash of Array",

	"Hash of Hash",

};



#define NR_TESTS (sizeof(test_names) / sizeof(*test_names))



static void populate_map(uint32_t port_key, int magic_result)

{

	int ret;



	ret = bpf_map_update_elem(PORT_A, &port_key, &magic_result, BPF_ANY);

	assert(!ret);



	ret = bpf_map_update_elem(PORT_H, &port_key, &magic_result,

				  BPF_NOEXIST);

	assert(!ret);



	ret = bpf_map_update_elem(A_OF_PORT_A, &port_key, &PORT_A, BPF_ANY);

	assert(!ret);



	ret = bpf_map_update_elem(H_OF_PORT_A, &port_key, &PORT_A, BPF_NOEXIST);

	assert(!ret);



	ret = bpf_map_update_elem(H_OF_PORT_H, &port_key, &PORT_H, BPF_NOEXIST);

	assert(!ret);

}



static void test_map_in_map(void)

{

	struct sockaddr_in6 in6 = { .sin6_family = AF_INET6 };

	uint32_t result_key = 0, port_key;

	int result, inline_result;

	int magic_result = 0xfaceb00c;

	int ret;

	int i;



	port_key = rand() & 0x00FF;

	populate_map(port_key, magic_result);



	in6.sin6_addr.s6_addr16[0] = 0xdead;

	in6.sin6_addr.s6_addr16[1] = 0xbeef;

	in6.sin6_port = port_key;



	for (i = 0; i < NR_TESTS; i++) {

		printf("%s: ", test_names[i]);



		in6.sin6_addr.s6_addr16[7] = i;

		ret = connect(-1, (struct sockaddr *)&in6, sizeof(in6));

		assert(ret == -1 && errno == EBADF);



		ret = bpf_map_lookup_elem(REG_RESULT_H, &result_key, &result);

		assert(!ret);



		ret = bpf_map_lookup_elem(INLINE_RESULT_H, &result_key,

					  &inline_result);

		assert(!ret);



		if (result != magic_result || inline_result != magic_result) {

			printf("Error. result:%d inline_result:%d\n",

			       result, inline_result);

			exit(1);

		}



		bpf_map_delete_elem(REG_RESULT_H, &result_key);

		bpf_map_delete_elem(INLINE_RESULT_H, &result_key);



		printf("Pass\n");

	}

}



int main(int argc, char **argv)

{

	struct rlimit r = {RLIM_INFINITY, RLIM_INFINITY};

	char filename[256];



	assert(!setrlimit(RLIMIT_MEMLOCK, &r));



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



	if (load_bpf_file(filename)) {

		printf("%s", bpf_log_buf);

		return 1;

	}



	test_map_in_map();



	return 0;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE