1// SPDX-License-Identifier: GPL-2.0
  2/* Copyright (c) 2021 Facebook */
  3#include <test_progs.h>
  4#include <network_helpers.h>
  5#include "for_each_hash_map_elem.skel.h"
  6#include "for_each_array_map_elem.skel.h"
  7#include "for_each_map_elem_write_key.skel.h"
  8
  9static unsigned int duration;
 10
 11static void test_hash_map(void)
 12{
 13	int i, err, max_entries;
 14	struct for_each_hash_map_elem *skel;
 15	__u64 *percpu_valbuf = NULL;
 16	size_t percpu_val_sz;
 17	__u32 key, num_cpus;
 18	__u64 val;
 19	LIBBPF_OPTS(bpf_test_run_opts, topts,
 20		.data_in = &pkt_v4,
 21		.data_size_in = sizeof(pkt_v4),
 22		.repeat = 1,
 23	);
 24
 25	skel = for_each_hash_map_elem__open_and_load();
 26	if (!ASSERT_OK_PTR(skel, "for_each_hash_map_elem__open_and_load"))
 27		return;
 28
 29	max_entries = bpf_map__max_entries(skel->maps.hashmap);
 30	for (i = 0; i < max_entries; i++) {
 31		key = i;
 32		val = i + 1;
 33		err = bpf_map__update_elem(skel->maps.hashmap, &key, sizeof(key),
 34					   &val, sizeof(val), BPF_ANY);
 35		if (!ASSERT_OK(err, "map_update"))
 36			goto out;
 37	}
 38
 39	num_cpus = bpf_num_possible_cpus();
 40	percpu_val_sz = sizeof(__u64) * num_cpus;
 41	percpu_valbuf = malloc(percpu_val_sz);
 42	if (!ASSERT_OK_PTR(percpu_valbuf, "percpu_valbuf"))
 43		goto out;
 44
 45	key = 1;
 46	for (i = 0; i < num_cpus; i++)
 47		percpu_valbuf[i] = i + 1;
 48	err = bpf_map__update_elem(skel->maps.percpu_map, &key, sizeof(key),
 49				   percpu_valbuf, percpu_val_sz, BPF_ANY);
 50	if (!ASSERT_OK(err, "percpu_map_update"))
 51		goto out;
 52
 53	err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_pkt_access), &topts);
 54	duration = topts.duration;
 55	if (CHECK(err || topts.retval, "ipv4", "err %d errno %d retval %d\n",
 56		  err, errno, topts.retval))
 57		goto out;
 58
 59	ASSERT_EQ(skel->bss->hashmap_output, 4, "hashmap_output");
 60	ASSERT_EQ(skel->bss->hashmap_elems, max_entries, "hashmap_elems");
 61
 62	key = 1;
 63	err = bpf_map__lookup_elem(skel->maps.hashmap, &key, sizeof(key), &val, sizeof(val), 0);
 64	ASSERT_ERR(err, "hashmap_lookup");
 65
 66	ASSERT_EQ(skel->bss->percpu_called, 1, "percpu_called");
 67	ASSERT_LT(skel->bss->cpu, num_cpus, "num_cpus");
 68	ASSERT_EQ(skel->bss->percpu_map_elems, 1, "percpu_map_elems");
 69	ASSERT_EQ(skel->bss->percpu_key, 1, "percpu_key");
 70	ASSERT_EQ(skel->bss->percpu_val, skel->bss->cpu + 1, "percpu_val");
 71	ASSERT_EQ(skel->bss->percpu_output, 100, "percpu_output");
 72out:
 73	free(percpu_valbuf);
 74	for_each_hash_map_elem__destroy(skel);
 75}
 76
 77static void test_array_map(void)
 78{
 79	__u32 key, num_cpus, max_entries;
 80	int i, err;
 81	struct for_each_array_map_elem *skel;
 82	__u64 *percpu_valbuf = NULL;
 83	size_t percpu_val_sz;
 84	__u64 val, expected_total;
 85	LIBBPF_OPTS(bpf_test_run_opts, topts,
 86		.data_in = &pkt_v4,
 87		.data_size_in = sizeof(pkt_v4),
 88		.repeat = 1,
 89	);
 90
 91	skel = for_each_array_map_elem__open_and_load();
 92	if (!ASSERT_OK_PTR(skel, "for_each_array_map_elem__open_and_load"))
 93		return;
 94
 95	expected_total = 0;
 96	max_entries = bpf_map__max_entries(skel->maps.arraymap);
 97	for (i = 0; i < max_entries; i++) {
 98		key = i;
 99		val = i + 1;
100		/* skip the last iteration for expected total */
101		if (i != max_entries - 1)
102			expected_total += val;
103		err = bpf_map__update_elem(skel->maps.arraymap, &key, sizeof(key),
104					   &val, sizeof(val), BPF_ANY);
105		if (!ASSERT_OK(err, "map_update"))
106			goto out;
107	}
108
109	num_cpus = bpf_num_possible_cpus();
110	percpu_val_sz = sizeof(__u64) * num_cpus;
111	percpu_valbuf = malloc(percpu_val_sz);
112	if (!ASSERT_OK_PTR(percpu_valbuf, "percpu_valbuf"))
113		goto out;
114
115	key = 0;
116	for (i = 0; i < num_cpus; i++)
117		percpu_valbuf[i] = i + 1;
118	err = bpf_map__update_elem(skel->maps.percpu_map, &key, sizeof(key),
119				   percpu_valbuf, percpu_val_sz, BPF_ANY);
120	if (!ASSERT_OK(err, "percpu_map_update"))
121		goto out;
122
123	err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_pkt_access), &topts);
124	duration = topts.duration;
125	if (CHECK(err || topts.retval, "ipv4", "err %d errno %d retval %d\n",
126		  err, errno, topts.retval))
127		goto out;
128
129	ASSERT_EQ(skel->bss->arraymap_output, expected_total, "array_output");
130	ASSERT_EQ(skel->bss->cpu + 1, skel->bss->percpu_val, "percpu_val");
131
132out:
133	free(percpu_valbuf);
134	for_each_array_map_elem__destroy(skel);
135}
136
137static void test_write_map_key(void)
138{
139	struct for_each_map_elem_write_key *skel;
140
141	skel = for_each_map_elem_write_key__open_and_load();
142	if (!ASSERT_ERR_PTR(skel, "for_each_map_elem_write_key__open_and_load"))
143		for_each_map_elem_write_key__destroy(skel);
144}
145
146void test_for_each(void)
147{
148	if (test__start_subtest("hash_map"))
149		test_hash_map();
150	if (test__start_subtest("array_map"))
151		test_array_map();
152	if (test__start_subtest("write_map_key"))
153		test_write_map_key();
154}