cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

for_each.c (4534B)

      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}