Commit 42fce2cf authored by Andrii Nakryiko's avatar Andrii Nakryiko Committed by Alexei Starovoitov
Browse files

selftests/bpf: Convert test_hashmap into test_progs test 



Fold stand-alone test_hashmap test into test_progs.

Signed-off-by: default avatarAndrii Nakryiko <andriin@fb.com>
Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20200429012111.277390-4-andriin@fb.com
parent 02995dd4

tools/testing/selftests/bpf/.gitignore

+0 −2
Original line number Diff line number Diff line
@@ -30,8 +30,6 @@ test_tcpnotify_user 
test_libbpf

test_tcp_check_syncookie_user

test_sysctl

test_hashmap

test_btf_dump

test_current_pid_tgid_new_ns

xdping

test_cpp

tools/testing/selftests/bpf/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -33,7 +33,7 @@ TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map test 
	test_align test_verifier_log test_dev_cgroup test_tcpbpf_user \

	test_sock test_btf test_sockmap get_cgroup_id_user test_socket_cookie \

	test_cgroup_storage \

	test_netcnt test_tcpnotify_user test_sock_fields test_sysctl test_hashmap \

	test_netcnt test_tcpnotify_user test_sock_fields test_sysctl \

	test_progs-no_alu32 \

	test_current_pid_tgid_new_ns

tools/testing/selftests/bpf/test_hashmap.c→tools/testing/selftests/bpf/prog_tests/hashmap.c

+139 −141
Original line number Diff line number Diff line
@@ -5,26 +5,17 @@ 
 *

 * Copyright (c) 2019 Facebook

 */

#include <stdio.h>

#include <errno.h>

#include <linux/err.h>

#include "test_progs.h"

#include "bpf/hashmap.h"



#define CHECK(condition, format...) ({					\

	int __ret = !!(condition);					\

	if (__ret) {							\

		fprintf(stderr, "%s:%d:FAIL ", __func__, __LINE__);	\

		fprintf(stderr, format);				\

	}								\

	__ret;								\

})

static int duration = 0;



size_t hash_fn(const void *k, void *ctx)

static size_t hash_fn(const void *k, void *ctx)

{

	return (long)k;

}



bool equal_fn(const void *a, const void *b, void *ctx)

static bool equal_fn(const void *a, const void *b, void *ctx)

{

	return (long)a == (long)b;

}
@@ -49,53 +40,55 @@ static inline size_t exp_cap(size_t sz) 


#define ELEM_CNT 62



int test_hashmap_generic(void)

static void test_hashmap_generic(void)

{

	struct hashmap_entry *entry, *tmp;

	int err, bkt, found_cnt, i;

	long long found_msk;

	struct hashmap *map;



	fprintf(stderr, "%s: ", __func__);



	map = hashmap__new(hash_fn, equal_fn, NULL);

	if (CHECK(IS_ERR(map), "failed to create map: %ld\n", PTR_ERR(map)))

		return 1;

	if (CHECK(IS_ERR(map), "hashmap__new",

		  "failed to create map: %ld\n", PTR_ERR(map)))

		return;



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

		const void *oldk, *k = (const void *)(long)i;

		void *oldv, *v = (void *)(long)(1024 + i);



		err = hashmap__update(map, k, v, &oldk, &oldv);

		if (CHECK(err != -ENOENT, "unexpected result: %d\n", err))

			return 1;

		if (CHECK(err != -ENOENT, "hashmap__update",

			  "unexpected result: %d\n", err))

			goto cleanup;



		if (i % 2) {

			err = hashmap__add(map, k, v);

		} else {

			err = hashmap__set(map, k, v, &oldk, &oldv);

			if (CHECK(oldk != NULL || oldv != NULL,

			if (CHECK(oldk != NULL || oldv != NULL, "check_kv",

				  "unexpected k/v: %p=%p\n", oldk, oldv))

				return 1;

				goto cleanup;

		}



		if (CHECK(err, "failed to add k/v %ld = %ld: %d\n",

		if (CHECK(err, "elem_add", "failed to add k/v %ld = %ld: %d\n",

			       (long)k, (long)v, err))

			return 1;

			goto cleanup;



		if (CHECK(!hashmap__find(map, k, &oldv),

		if (CHECK(!hashmap__find(map, k, &oldv), "elem_find",

			  "failed to find key %ld\n", (long)k))

			return 1;

		if (CHECK(oldv != v, "found value is wrong: %ld\n", (long)oldv))

			return 1;

			goto cleanup;

		if (CHECK(oldv != v, "elem_val",

			  "found value is wrong: %ld\n", (long)oldv))

			goto cleanup;

	}



	if (CHECK(hashmap__size(map) != ELEM_CNT,

	if (CHECK(hashmap__size(map) != ELEM_CNT, "hashmap__size",

		  "invalid map size: %zu\n", hashmap__size(map)))

		return 1;

		goto cleanup;

	if (CHECK(hashmap__capacity(map) != exp_cap(hashmap__size(map)),

		  "hashmap_cap",

		  "unexpected map capacity: %zu\n", hashmap__capacity(map)))

		return 1;

		goto cleanup;



	found_msk = 0;

	hashmap__for_each_entry(map, entry, bkt) {
@@ -103,42 +96,47 @@ int test_hashmap_generic(void) 
		long v = (long)entry->value;



		found_msk |= 1ULL << k;

		if (CHECK(v - k != 1024, "invalid k/v pair: %ld = %ld\n", k, v))

			return 1;

		if (CHECK(v - k != 1024, "check_kv",

			  "invalid k/v pair: %ld = %ld\n", k, v))

			goto cleanup;

	}

	if (CHECK(found_msk != (1ULL << ELEM_CNT) - 1,

	if (CHECK(found_msk != (1ULL << ELEM_CNT) - 1, "elem_cnt",

		  "not all keys iterated: %llx\n", found_msk))

		return 1;

		goto cleanup;



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

		const void *oldk, *k = (const void *)(long)i;

		void *oldv, *v = (void *)(long)(256 + i);



		err = hashmap__add(map, k, v);

		if (CHECK(err != -EEXIST, "unexpected add result: %d\n", err))

			return 1;

		if (CHECK(err != -EEXIST, "hashmap__add",

			  "unexpected add result: %d\n", err))

			goto cleanup;



		if (i % 2)

			err = hashmap__update(map, k, v, &oldk, &oldv);

		else

			err = hashmap__set(map, k, v, &oldk, &oldv);



		if (CHECK(err, "failed to update k/v %ld = %ld: %d\n",

		if (CHECK(err, "elem_upd",

			  "failed to update k/v %ld = %ld: %d\n",

			  (long)k, (long)v, err))

			return 1;

		if (CHECK(!hashmap__find(map, k, &oldv),

			goto cleanup;

		if (CHECK(!hashmap__find(map, k, &oldv), "elem_find",

			  "failed to find key %ld\n", (long)k))

			return 1;

		if (CHECK(oldv != v, "found value is wrong: %ld\n", (long)oldv))

			return 1;

			goto cleanup;

		if (CHECK(oldv != v, "elem_val",

			  "found value is wrong: %ld\n", (long)oldv))

			goto cleanup;

	}



	if (CHECK(hashmap__size(map) != ELEM_CNT,

	if (CHECK(hashmap__size(map) != ELEM_CNT, "hashmap__size",

		  "invalid updated map size: %zu\n", hashmap__size(map)))

		return 1;

		goto cleanup;

	if (CHECK(hashmap__capacity(map) != exp_cap(hashmap__size(map)),

		  "hashmap__capacity",

		  "unexpected map capacity: %zu\n", hashmap__capacity(map)))

		return 1;

		goto cleanup;



	found_msk = 0;

	hashmap__for_each_entry_safe(map, entry, tmp, bkt) {
@@ -146,20 +144,21 @@ int test_hashmap_generic(void) 
		long v = (long)entry->value;



		found_msk |= 1ULL << k;

		if (CHECK(v - k != 256,

		if (CHECK(v - k != 256, "elem_check",

			  "invalid updated k/v pair: %ld = %ld\n", k, v))

			return 1;

			goto cleanup;

	}

	if (CHECK(found_msk != (1ULL << ELEM_CNT) - 1,

	if (CHECK(found_msk != (1ULL << ELEM_CNT) - 1, "elem_cnt",

		  "not all keys iterated after update: %llx\n", found_msk))

		return 1;

		goto cleanup;



	found_cnt = 0;

	hashmap__for_each_key_entry(map, entry, (void *)0) {

		found_cnt++;

	}

	if (CHECK(!found_cnt, "didn't find any entries for key 0\n"))

		return 1;

	if (CHECK(!found_cnt, "found_cnt",

		  "didn't find any entries for key 0\n"))

		goto cleanup;



	found_msk = 0;

	found_cnt = 0;
@@ -173,30 +172,31 @@ int test_hashmap_generic(void) 
		found_cnt++;

		found_msk |= 1ULL << (long)k;



		if (CHECK(!hashmap__delete(map, k, &oldk, &oldv),

		if (CHECK(!hashmap__delete(map, k, &oldk, &oldv), "elem_del",

			  "failed to delete k/v %ld = %ld\n",

			  (long)k, (long)v))

			return 1;

		if (CHECK(oldk != k || oldv != v,

			goto cleanup;

		if (CHECK(oldk != k || oldv != v, "check_old",

			  "invalid deleted k/v: expected %ld = %ld, got %ld = %ld\n",

			  (long)k, (long)v, (long)oldk, (long)oldv))

			return 1;

		if (CHECK(hashmap__delete(map, k, &oldk, &oldv),

			goto cleanup;

		if (CHECK(hashmap__delete(map, k, &oldk, &oldv), "elem_del",

			  "unexpectedly deleted k/v %ld = %ld\n",

			  (long)oldk, (long)oldv))

			return 1;

			goto cleanup;

	}



	if (CHECK(!found_cnt || !found_msk,

	if (CHECK(!found_cnt || !found_msk, "found_entries",

		  "didn't delete any key entries\n"))

		return 1;

	if (CHECK(hashmap__size(map) != ELEM_CNT - found_cnt,

		goto cleanup;

	if (CHECK(hashmap__size(map) != ELEM_CNT - found_cnt, "elem_cnt",

		  "invalid updated map size (already deleted: %d): %zu\n",

		  found_cnt, hashmap__size(map)))

		return 1;

		goto cleanup;

	if (CHECK(hashmap__capacity(map) != exp_cap(hashmap__size(map)),

		  "hashmap__capacity",

		  "unexpected map capacity: %zu\n", hashmap__capacity(map)))

		return 1;

		goto cleanup;



	hashmap__for_each_entry_safe(map, entry, tmp, bkt) {

		const void *oldk, *k;
@@ -208,53 +208,56 @@ int test_hashmap_generic(void) 
		found_cnt++;

		found_msk |= 1ULL << (long)k;



		if (CHECK(!hashmap__delete(map, k, &oldk, &oldv),

		if (CHECK(!hashmap__delete(map, k, &oldk, &oldv), "elem_del",

			  "failed to delete k/v %ld = %ld\n",

			  (long)k, (long)v))

			return 1;

		if (CHECK(oldk != k || oldv != v,

			goto cleanup;

		if (CHECK(oldk != k || oldv != v, "elem_check",

			  "invalid old k/v: expect %ld = %ld, got %ld = %ld\n",

			  (long)k, (long)v, (long)oldk, (long)oldv))

			return 1;

		if (CHECK(hashmap__delete(map, k, &oldk, &oldv),

			goto cleanup;

		if (CHECK(hashmap__delete(map, k, &oldk, &oldv), "elem_del",

			  "unexpectedly deleted k/v %ld = %ld\n",

			  (long)k, (long)v))

			return 1;

			goto cleanup;

	}



	if (CHECK(found_cnt != ELEM_CNT || found_msk != (1ULL << ELEM_CNT) - 1,

		  "found_cnt",

		  "not all keys were deleted: found_cnt:%d, found_msk:%llx\n",

		  found_cnt, found_msk))

		return 1;

	if (CHECK(hashmap__size(map) != 0,

		goto cleanup;

	if (CHECK(hashmap__size(map) != 0, "hashmap__size",

		  "invalid updated map size (already deleted: %d): %zu\n",

		  found_cnt, hashmap__size(map)))

		return 1;

		goto cleanup;



	found_cnt = 0;

	hashmap__for_each_entry(map, entry, bkt) {

		CHECK(false, "unexpected map entries left: %ld = %ld\n",

		CHECK(false, "elem_exists",

		      "unexpected map entries left: %ld = %ld\n",

		      (long)entry->key, (long)entry->value);

		return 1;

		goto cleanup;

	}



	hashmap__free(map);

	hashmap__clear(map);

	hashmap__for_each_entry(map, entry, bkt) {

		CHECK(false, "unexpected map entries left: %ld = %ld\n",

		CHECK(false, "elem_exists",

		      "unexpected map entries left: %ld = %ld\n",

		      (long)entry->key, (long)entry->value);

		return 1;

		goto cleanup;

	}



	fprintf(stderr, "OK\n");

	return 0;

cleanup:

	hashmap__free(map);

}



size_t collision_hash_fn(const void *k, void *ctx)

static size_t collision_hash_fn(const void *k, void *ctx)

{

	return 0;

}



int test_hashmap_multimap(void)

static void test_hashmap_multimap(void)

{

	void *k1 = (void *)0, *k2 = (void *)1;

	struct hashmap_entry *entry;
@@ -262,121 +265,116 @@ int test_hashmap_multimap(void) 
	long found_msk;

	int err, bkt;



	fprintf(stderr, "%s: ", __func__);



	/* force collisions */

	map = hashmap__new(collision_hash_fn, equal_fn, NULL);

	if (CHECK(IS_ERR(map), "failed to create map: %ld\n", PTR_ERR(map)))

		return 1;



	if (CHECK(IS_ERR(map), "hashmap__new",

		  "failed to create map: %ld\n", PTR_ERR(map)))

		return;



	/* set up multimap:

	 * [0] -> 1, 2, 4;

	 * [1] -> 8, 16, 32;

	 */

	err = hashmap__append(map, k1, (void *)1);

	if (CHECK(err, "failed to add k/v: %d\n", err))

		return 1;

	if (CHECK(err, "elem_add", "failed to add k/v: %d\n", err))

		goto cleanup;

	err = hashmap__append(map, k1, (void *)2);

	if (CHECK(err, "failed to add k/v: %d\n", err))

		return 1;

	if (CHECK(err, "elem_add", "failed to add k/v: %d\n", err))

		goto cleanup;

	err = hashmap__append(map, k1, (void *)4);

	if (CHECK(err, "failed to add k/v: %d\n", err))

		return 1;

	if (CHECK(err, "elem_add", "failed to add k/v: %d\n", err))

		goto cleanup;



	err = hashmap__append(map, k2, (void *)8);

	if (CHECK(err, "failed to add k/v: %d\n", err))

		return 1;

	if (CHECK(err, "elem_add", "failed to add k/v: %d\n", err))

		goto cleanup;

	err = hashmap__append(map, k2, (void *)16);

	if (CHECK(err, "failed to add k/v: %d\n", err))

		return 1;

	if (CHECK(err, "elem_add", "failed to add k/v: %d\n", err))

		goto cleanup;

	err = hashmap__append(map, k2, (void *)32);

	if (CHECK(err, "failed to add k/v: %d\n", err))

		return 1;

	if (CHECK(err, "elem_add", "failed to add k/v: %d\n", err))

		goto cleanup;



	if (CHECK(hashmap__size(map) != 6,

	if (CHECK(hashmap__size(map) != 6, "hashmap_size",

		  "invalid map size: %zu\n", hashmap__size(map)))

		return 1;

		goto cleanup;



	/* verify global iteration still works and sees all values */

	found_msk = 0;

	hashmap__for_each_entry(map, entry, bkt) {

		found_msk |= (long)entry->value;

	}

	if (CHECK(found_msk != (1 << 6) - 1,

	if (CHECK(found_msk != (1 << 6) - 1, "found_msk",

		  "not all keys iterated: %lx\n", found_msk))

		return 1;

		goto cleanup;



	/* iterate values for key 1 */

	found_msk = 0;

	hashmap__for_each_key_entry(map, entry, k1) {

		found_msk |= (long)entry->value;

	}

	if (CHECK(found_msk != (1 | 2 | 4),

	if (CHECK(found_msk != (1 | 2 | 4), "found_msk",

		  "invalid k1 values: %lx\n", found_msk))

		return 1;

		goto cleanup;



	/* iterate values for key 2 */

	found_msk = 0;

	hashmap__for_each_key_entry(map, entry, k2) {

		found_msk |= (long)entry->value;

	}

	if (CHECK(found_msk != (8 | 16 | 32),

	if (CHECK(found_msk != (8 | 16 | 32), "found_msk",

		  "invalid k2 values: %lx\n", found_msk))

		return 1;

		goto cleanup;



	fprintf(stderr, "OK\n");

	return 0;

cleanup:

	hashmap__free(map);

}



int test_hashmap_empty()

static void test_hashmap_empty()

{

	struct hashmap_entry *entry;

	int bkt;

	struct hashmap *map;

	void *k = (void *)0;



	fprintf(stderr, "%s: ", __func__);



	/* force collisions */

	map = hashmap__new(hash_fn, equal_fn, NULL);

	if (CHECK(IS_ERR(map), "failed to create map: %ld\n", PTR_ERR(map)))

		return 1;

	if (CHECK(IS_ERR(map), "hashmap__new",

		  "failed to create map: %ld\n", PTR_ERR(map)))

		goto cleanup;



	if (CHECK(hashmap__size(map) != 0,

	if (CHECK(hashmap__size(map) != 0, "hashmap__size",

		  "invalid map size: %zu\n", hashmap__size(map)))

		return 1;

	if (CHECK(hashmap__capacity(map) != 0,

		goto cleanup;

	if (CHECK(hashmap__capacity(map) != 0, "hashmap__capacity",

		  "invalid map capacity: %zu\n", hashmap__capacity(map)))

		return 1;

	if (CHECK(hashmap__find(map, k, NULL), "unexpected find\n"))

		return 1;

	if (CHECK(hashmap__delete(map, k, NULL, NULL), "unexpected delete\n"))

		return 1;

		goto cleanup;

	if (CHECK(hashmap__find(map, k, NULL), "elem_find",

		  "unexpected find\n"))

		goto cleanup;

	if (CHECK(hashmap__delete(map, k, NULL, NULL), "elem_del",

		  "unexpected delete\n"))

		goto cleanup;



	hashmap__for_each_entry(map, entry, bkt) {

		CHECK(false, "unexpected iterated entry\n");

		return 1;

		CHECK(false, "elem_found", "unexpected iterated entry\n");

		goto cleanup;

	}

	hashmap__for_each_key_entry(map, entry, k) {

		CHECK(false, "unexpected key entry\n");

		return 1;

		CHECK(false, "key_found", "unexpected key entry\n");

		goto cleanup;

	}



	fprintf(stderr, "OK\n");

	return 0;

cleanup:

	hashmap__free(map);

}



int main(int argc, char **argv)

void test_hashmap()

{

	bool failed = false;



	if (test_hashmap_generic())

		failed = true;

	if (test_hashmap_multimap())

		failed = true;

	if (test_hashmap_empty())

		failed = true;



	return failed;

	if (test__start_subtest("generic"))

		test_hashmap_generic();

	if (test__start_subtest("multimap"))

		test_hashmap_multimap();

	if (test__start_subtest("empty"))

		test_hashmap_empty();

}