[linux-block.git] / samples / bpf / test_map_in_map_user.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2017 Facebook
 */
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdint.h>
#include <assert.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <bpf/bpf.h>
#include <bpf/libbpf.h>

#include "bpf_util.h"

static int map_fd[7];

#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 ARRAY_SIZE(test_names)

static void check_map_id(int inner_map_fd, int map_in_map_fd, uint32_t key)
{
	struct bpf_map_info info = {};
	uint32_t info_len = sizeof(info);
	int ret, id;

	ret = bpf_map_get_info_by_fd(inner_map_fd, &info, &info_len);
	assert(!ret);

	ret = bpf_map_lookup_elem(map_in_map_fd, &key, &id);
	assert(!ret);
	assert(id == info.id);
}

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);
	check_map_id(PORT_A, A_OF_PORT_A, port_key);

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

	ret = bpf_map_update_elem(H_OF_PORT_H, &port_key, &PORT_H, BPF_NOEXIST);
	assert(!ret);
	check_map_id(PORT_H, H_OF_PORT_H, port_key);
}

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 bpf_link *link = NULL;
	struct bpf_program *prog;
	struct bpf_object *obj;
	char filename[256];

	snprintf(filename, sizeof(filename), "%s.bpf.o", argv[0]);
	obj = bpf_object__open_file(filename, NULL);
	if (libbpf_get_error(obj)) {
		fprintf(stderr, "ERROR: opening BPF object file failed\n");
		return 0;
	}

	prog = bpf_object__find_program_by_name(obj, "trace_sys_connect");
	if (!prog) {
		printf("finding a prog in obj file failed\n");
		goto cleanup;
	}

	/* load BPF program */
	if (bpf_object__load(obj)) {
		fprintf(stderr, "ERROR: loading BPF object file failed\n");
		goto cleanup;
	}

	map_fd[0] = bpf_object__find_map_fd_by_name(obj, "port_a");
	map_fd[1] = bpf_object__find_map_fd_by_name(obj, "port_h");
	map_fd[2] = bpf_object__find_map_fd_by_name(obj, "reg_result_h");
	map_fd[3] = bpf_object__find_map_fd_by_name(obj, "inline_result_h");
	map_fd[4] = bpf_object__find_map_fd_by_name(obj, "a_of_port_a");
	map_fd[5] = bpf_object__find_map_fd_by_name(obj, "h_of_port_a");
	map_fd[6] = bpf_object__find_map_fd_by_name(obj, "h_of_port_h");
	if (map_fd[0] < 0 || map_fd[1] < 0 || map_fd[2] < 0 ||
	    map_fd[3] < 0 || map_fd[4] < 0 || map_fd[5] < 0 || map_fd[6] < 0) {
		fprintf(stderr, "ERROR: finding a map in obj file failed\n");
		goto cleanup;
	}

	link = bpf_program__attach(prog);
	if (libbpf_get_error(link)) {
		fprintf(stderr, "ERROR: bpf_program__attach failed\n");
		link = NULL;
		goto cleanup;
	}

	test_map_in_map();

cleanup:
	bpf_link__destroy(link);
	bpf_object__close(obj);
	return 0;
}
Commit	Line	Data
25763b3c	1	// SPDX-License-Identifier: GPL-2.0-only
fb30d4b7 MKL	2	/*
fb30d4b7 MKL	3	* Copyright (c) 2017 Facebook
fb30d4b7	4	*/
fb30d4b7 MKL	5	#include <sys/socket.h>
	6	#include <arpa/inet.h>
	7	#include <stdint.h>
	8	#include <assert.h>
	9	#include <errno.h>
	10	#include <stdlib.h>
	11	#include <stdio.h>
2bf3e2ef	12	#include <bpf/bpf.h>
88795b4a DL	13	#include <bpf/libbpf.h>
88795b4a DL	14
b1fc28b3 LX	15	#include "bpf_util.h"
b1fc28b3 LX	16
88795b4a	17	static int map_fd[7];
fb30d4b7 MKL	18
	19	#define PORT_A (map_fd[0])
	20	#define PORT_H (map_fd[1])
	21	#define REG_RESULT_H (map_fd[2])
	22	#define INLINE_RESULT_H (map_fd[3])
	23	#define A_OF_PORT_A (map_fd[4]) /* Test case #0 */
	24	#define H_OF_PORT_A (map_fd[5]) /* Test case #1 */
	25	#define H_OF_PORT_H (map_fd[6]) /* Test case #2 */
	26
	27	static const char * const test_names[] = {
	28	"Array of Array",
	29	"Hash of Array",
	30	"Hash of Hash",
	31	};
	32
b1fc28b3	33	#define NR_TESTS ARRAY_SIZE(test_names)
fb30d4b7	34
a8744f25 MKL	35	static void check_map_id(int inner_map_fd, int map_in_map_fd, uint32_t key)
	36	{
	37	struct bpf_map_info info = {};
	38	uint32_t info_len = sizeof(info);
	39	int ret, id;
	40
c0ca277b	41	ret = bpf_map_get_info_by_fd(inner_map_fd, &info, &info_len);
a8744f25 MKL	42	assert(!ret);
	43
	44	ret = bpf_map_lookup_elem(map_in_map_fd, &key, &id);
	45	assert(!ret);
	46	assert(id == info.id);
	47	}
	48
fb30d4b7 MKL	49	static void populate_map(uint32_t port_key, int magic_result)
	50	{
	51	int ret;
	52
	53	ret = bpf_map_update_elem(PORT_A, &port_key, &magic_result, BPF_ANY);
	54	assert(!ret);
	55
	56	ret = bpf_map_update_elem(PORT_H, &port_key, &magic_result,
	57	BPF_NOEXIST);
	58	assert(!ret);
	59
	60	ret = bpf_map_update_elem(A_OF_PORT_A, &port_key, &PORT_A, BPF_ANY);
	61	assert(!ret);
a8744f25	62	check_map_id(PORT_A, A_OF_PORT_A, port_key);
fb30d4b7 MKL	63
	64	ret = bpf_map_update_elem(H_OF_PORT_A, &port_key, &PORT_A, BPF_NOEXIST);
	65	assert(!ret);
a8744f25	66	check_map_id(PORT_A, H_OF_PORT_A, port_key);
fb30d4b7 MKL	67
	68	ret = bpf_map_update_elem(H_OF_PORT_H, &port_key, &PORT_H, BPF_NOEXIST);
	69	assert(!ret);
a8744f25	70	check_map_id(PORT_H, H_OF_PORT_H, port_key);
fb30d4b7 MKL	71	}
	72
	73	static void test_map_in_map(void)
	74	{
	75	struct sockaddr_in6 in6 = { .sin6_family = AF_INET6 };
	76	uint32_t result_key = 0, port_key;
	77	int result, inline_result;
	78	int magic_result = 0xfaceb00c;
	79	int ret;
	80	int i;
	81
	82	port_key = rand() & 0x00FF;
	83	populate_map(port_key, magic_result);
	84
	85	in6.sin6_addr.s6_addr16[0] = 0xdead;
	86	in6.sin6_addr.s6_addr16[1] = 0xbeef;
	87	in6.sin6_port = port_key;
	88
	89	for (i = 0; i < NR_TESTS; i++) {
	90	printf("%s: ", test_names[i]);
	91
	92	in6.sin6_addr.s6_addr16[7] = i;
	93	ret = connect(-1, (struct sockaddr *)&in6, sizeof(in6));
	94	assert(ret == -1 && errno == EBADF);
	95
	96	ret = bpf_map_lookup_elem(REG_RESULT_H, &result_key, &result);
	97	assert(!ret);
	98
	99	ret = bpf_map_lookup_elem(INLINE_RESULT_H, &result_key,
	100	&inline_result);
	101	assert(!ret);
	102
	103	if (result != magic_result \|\| inline_result != magic_result) {
	104	printf("Error. result:%d inline_result:%d\n",
	105	result, inline_result);
	106	exit(1);
	107	}
	108
	109	bpf_map_delete_elem(REG_RESULT_H, &result_key);
	110	bpf_map_delete_elem(INLINE_RESULT_H, &result_key);
	111
	112	printf("Pass\n");
	113	}
	114	}
	115
	116	int main(int argc, char **argv)
	117	{
88795b4a DL	118	struct bpf_link *link = NULL;
	119	struct bpf_program *prog;
	120	struct bpf_object *obj;
fb30d4b7 MKL	121	char filename[256];
fb30d4b7 MKL	122
e04946f5	123	snprintf(filename, sizeof(filename), "%s.bpf.o", argv[0]);
88795b4a DL	124	obj = bpf_object__open_file(filename, NULL);
	125	if (libbpf_get_error(obj)) {
	126	fprintf(stderr, "ERROR: opening BPF object file failed\n");
	127	return 0;
	128	}
fb30d4b7	129
88795b4a DL	130	prog = bpf_object__find_program_by_name(obj, "trace_sys_connect");
	131	if (!prog) {
	132	printf("finding a prog in obj file failed\n");
	133	goto cleanup;
	134	}
	135
	136	/* load BPF program */
	137	if (bpf_object__load(obj)) {
	138	fprintf(stderr, "ERROR: loading BPF object file failed\n");
	139	goto cleanup;
	140	}
	141
	142	map_fd[0] = bpf_object__find_map_fd_by_name(obj, "port_a");
	143	map_fd[1] = bpf_object__find_map_fd_by_name(obj, "port_h");
	144	map_fd[2] = bpf_object__find_map_fd_by_name(obj, "reg_result_h");
	145	map_fd[3] = bpf_object__find_map_fd_by_name(obj, "inline_result_h");
	146	map_fd[4] = bpf_object__find_map_fd_by_name(obj, "a_of_port_a");
	147	map_fd[5] = bpf_object__find_map_fd_by_name(obj, "h_of_port_a");
	148	map_fd[6] = bpf_object__find_map_fd_by_name(obj, "h_of_port_h");
	149	if (map_fd[0] < 0 \|\| map_fd[1] < 0 \|\| map_fd[2] < 0 \|\|
	150	map_fd[3] < 0 \|\| map_fd[4] < 0 \|\| map_fd[5] < 0 \|\| map_fd[6] < 0) {
	151	fprintf(stderr, "ERROR: finding a map in obj file failed\n");
	152	goto cleanup;
	153	}
	154
	155	link = bpf_program__attach(prog);
	156	if (libbpf_get_error(link)) {
	157	fprintf(stderr, "ERROR: bpf_program__attach failed\n");
	158	link = NULL;
	159	goto cleanup;
fb30d4b7 MKL	160	}
	161
	162	test_map_in_map();
	163
88795b4a DL	164	cleanup:
	165	bpf_link__destroy(link);
	166	bpf_object__close(obj);
fb30d4b7 MKL	167	return 0;
fb30d4b7 MKL	168	}