linux/tools/testing/selftests/bpf/prog_tests/fd_htab_lookup.c

// SPDX-License-Identifier: GPL-2.0
/* Copyright (C) 2025. Huawei Technologies Co., Ltd */
#define _GNU_SOURCE
#include <stdbool.h>
#include <test_progs.h>
#include "fd_htab_lookup.skel.h"

struct htab_op_ctx {
	int fd;
	int loop;
	unsigned int entries;
	bool stop;
};

#define ERR_TO_RETVAL(where, err) ((void *)(long)(((where) << 12) | (-err)))

static void *htab_lookup_fn(void *arg)
{
	struct htab_op_ctx *ctx = arg;
	int i = 0;

	while (i++ < ctx->loop && !ctx->stop) {
		unsigned int j;

		for (j = 0; j < ctx->entries; j++) {
			unsigned int key = j, zero = 0, value;
			int inner_fd, err;

			err = bpf_map_lookup_elem(ctx->fd, &key, &value);
			if (err) {
				ctx->stop = true;
				return ERR_TO_RETVAL(1, err);
			}

			inner_fd = bpf_map_get_fd_by_id(value);
			if (inner_fd < 0) {
				/* The old map has been freed */
				if (inner_fd == -ENOENT)
					continue;
				ctx->stop = true;
				return ERR_TO_RETVAL(2, inner_fd);
			}

			err = bpf_map_lookup_elem(inner_fd, &zero, &value);
			if (err) {
				close(inner_fd);
				ctx->stop = true;
				return ERR_TO_RETVAL(3, err);
			}
			close(inner_fd);

			if (value != key) {
				ctx->stop = true;
				return ERR_TO_RETVAL(4, -EINVAL);
			}
		}
	}

	return NULL;
}

static void *htab_update_fn(void *arg)
{
	struct htab_op_ctx *ctx = arg;
	int i = 0;

	while (i++ < ctx->loop && !ctx->stop) {
		unsigned int j;

		for (j = 0; j < ctx->entries; j++) {
			unsigned int key = j, zero = 0;
			int inner_fd, err;

			inner_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, NULL, 4, 4, 1, NULL);
			if (inner_fd < 0) {
				ctx->stop = true;
				return ERR_TO_RETVAL(1, inner_fd);
			}

			err = bpf_map_update_elem(inner_fd, &zero, &key, 0);
			if (err) {
				close(inner_fd);
				ctx->stop = true;
				return ERR_TO_RETVAL(2, err);
			}

			err = bpf_map_update_elem(ctx->fd, &key, &inner_fd, BPF_EXIST);
			if (err) {
				close(inner_fd);
				ctx->stop = true;
				return ERR_TO_RETVAL(3, err);
			}
			close(inner_fd);
		}
	}

	return NULL;
}

static int setup_htab(int fd, unsigned int entries)
{
	unsigned int i;

	for (i = 0; i < entries; i++) {
		unsigned int key = i, zero = 0;
		int inner_fd, err;

		inner_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, NULL, 4, 4, 1, NULL);
		if (!ASSERT_OK_FD(inner_fd, "new array"))
			return -1;

		err = bpf_map_update_elem(inner_fd, &zero, &key, 0);
		if (!ASSERT_OK(err, "init array")) {
			close(inner_fd);
			return -1;
		}

		err = bpf_map_update_elem(fd, &key, &inner_fd, 0);
		if (!ASSERT_OK(err, "init outer")) {
			close(inner_fd);
			return -1;
		}
		close(inner_fd);
	}

	return 0;
}

static int get_int_from_env(const char *name, int dft)
{
	const char *value;

	value = getenv(name);
	if (!value)
		return dft;

	return atoi(value);
}

void test_fd_htab_lookup(void)
{
	unsigned int i, wr_nr = 8, rd_nr = 16;
	pthread_t tids[wr_nr + rd_nr];
	struct fd_htab_lookup *skel;
	struct htab_op_ctx ctx;
	int err;

	skel = fd_htab_lookup__open_and_load();
	if (!ASSERT_OK_PTR(skel, "fd_htab_lookup__open_and_load"))
		return;

	ctx.fd = bpf_map__fd(skel->maps.outer_map);
	ctx.loop = get_int_from_env("FD_HTAB_LOOP_NR", 5);
	ctx.stop = false;
	ctx.entries = 8;

	err = setup_htab(ctx.fd, ctx.entries);
	if (err)
		goto destroy;

	memset(tids, 0, sizeof(tids));
	for (i = 0; i < wr_nr; i++) {
		err = pthread_create(&tids[i], NULL, htab_update_fn, &ctx);
		if (!ASSERT_OK(err, "pthread_create")) {
			ctx.stop = true;
			goto reap;
		}
	}
	for (i = 0; i < rd_nr; i++) {
		err = pthread_create(&tids[i + wr_nr], NULL, htab_lookup_fn, &ctx);
		if (!ASSERT_OK(err, "pthread_create")) {
			ctx.stop = true;
			goto reap;
		}
	}

reap:
	for (i = 0; i < wr_nr + rd_nr; i++) {
		void *ret = NULL;
		char desc[32];

		if (!tids[i])
			continue;

		snprintf(desc, sizeof(desc), "thread %u", i + 1);
		err = pthread_join(tids[i], &ret);
		ASSERT_OK(err, desc);
		ASSERT_EQ(ret, NULL, desc);
	}
destroy:
	fd_htab_lookup__destroy(skel);
}