// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2021 Facebook */
#include <test_progs.h>
#include <network_helpers.h>
#include "for_each_hash_map_elem.skel.h"
#include "for_each_array_map_elem.skel.h"
#include "for_each_map_elem_write_key.skel.h"
#include "for_each_multi_maps.skel.h"
#include "for_each_hash_modify.skel.h"

static unsigned int duration;

static void test_hash_map(void)
{
        int i, err, max_entries;
        struct for_each_hash_map_elem *skel;
        __u64 *percpu_valbuf = NULL;
        size_t percpu_val_sz;
        __u32 key, num_cpus;
        __u64 val;
        LIBBPF_OPTS(bpf_test_run_opts, topts,
                .data_in = &pkt_v4,
                .data_size_in = sizeof(pkt_v4),
                .repeat = 1,
        );

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

        max_entries = bpf_map__max_entries(skel->maps.hashmap);
        for (i = 0; i < max_entries; i++) {
                key = i;
                val = i + 1;
                err = bpf_map__update_elem(skel->maps.hashmap, &key, sizeof(key),
                                           &val, sizeof(val), BPF_ANY);
                if (!ASSERT_OK(err, "map_update"))
                        goto out;
        }

        num_cpus = bpf_num_possible_cpus();
        percpu_val_sz = sizeof(__u64) * num_cpus;
        percpu_valbuf = malloc(percpu_val_sz);
        if (!ASSERT_OK_PTR(percpu_valbuf, "percpu_valbuf"))
                goto out;

        key = 1;
        for (i = 0; i < num_cpus; i++)
                percpu_valbuf[i] = i + 1;
        err = bpf_map__update_elem(skel->maps.percpu_map, &key, sizeof(key),
                                   percpu_valbuf, percpu_val_sz, BPF_ANY);
        if (!ASSERT_OK(err, "percpu_map_update"))
                goto out;

        err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_pkt_access), &topts);
        duration = topts.duration;
        if (CHECK(err || topts.retval, "ipv4", "err %d errno %d retval %d\n",
                  err, errno, topts.retval))
                goto out;

        ASSERT_EQ(skel->bss->hashmap_output, 4, "hashmap_output");
        ASSERT_EQ(skel->bss->hashmap_elems, max_entries, "hashmap_elems");

        key = 1;
        err = bpf_map__lookup_elem(skel->maps.hashmap, &key, sizeof(key), &val, sizeof(val), 0);
        ASSERT_ERR(err, "hashmap_lookup");

        ASSERT_EQ(skel->bss->percpu_called, 1, "percpu_called");
        ASSERT_LT(skel->bss->cpu, num_cpus, "num_cpus");
        ASSERT_EQ(skel->bss->percpu_map_elems, 1, "percpu_map_elems");
        ASSERT_EQ(skel->bss->percpu_key, 1, "percpu_key");
        ASSERT_EQ(skel->bss->percpu_val, skel->bss->cpu + 1, "percpu_val");
        ASSERT_EQ(skel->bss->percpu_output, 100, "percpu_output");
out:
        free(percpu_valbuf);
        for_each_hash_map_elem__destroy(skel);
}

static void test_array_map(void)
{
        __u32 key, num_cpus, max_entries;
        int i, err;
        struct for_each_array_map_elem *skel;
        __u64 *percpu_valbuf = NULL;
        size_t percpu_val_sz;
        __u64 val, expected_total;
        LIBBPF_OPTS(bpf_test_run_opts, topts,
                .data_in = &pkt_v4,
                .data_size_in = sizeof(pkt_v4),
                .repeat = 1,
        );

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

        expected_total = 0;
        max_entries = bpf_map__max_entries(skel->maps.arraymap);
        for (i = 0; i < max_entries; i++) {
                key = i;
                val = i + 1;
                /* skip the last iteration for expected total */
                if (i != max_entries - 1)
                        expected_total += val;
                err = bpf_map__update_elem(skel->maps.arraymap, &key, sizeof(key),
                                           &val, sizeof(val), BPF_ANY);
                if (!ASSERT_OK(err, "map_update"))
                        goto out;
        }

        num_cpus = bpf_num_possible_cpus();
        percpu_val_sz = sizeof(__u64) * num_cpus;
        percpu_valbuf = malloc(percpu_val_sz);
        if (!ASSERT_OK_PTR(percpu_valbuf, "percpu_valbuf"))
                goto out;

        key = 0;
        for (i = 0; i < num_cpus; i++)
                percpu_valbuf[i] = i + 1;
        err = bpf_map__update_elem(skel->maps.percpu_map, &key, sizeof(key),
                                   percpu_valbuf, percpu_val_sz, BPF_ANY);
        if (!ASSERT_OK(err, "percpu_map_update"))
                goto out;

        err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_pkt_access), &topts);
        duration = topts.duration;
        if (CHECK(err || topts.retval, "ipv4", "err %d errno %d retval %d\n",
                  err, errno, topts.retval))
                goto out;

        ASSERT_EQ(skel->bss->arraymap_output, expected_total, "array_output");
        ASSERT_EQ(skel->bss->cpu + 1, skel->bss->percpu_val, "percpu_val");

out:
        free(percpu_valbuf);
        for_each_array_map_elem__destroy(skel);
}

static void test_write_map_key(void)
{
        struct for_each_map_elem_write_key *skel;

        skel = for_each_map_elem_write_key__open_and_load();
        if (!ASSERT_ERR_PTR(skel, "for_each_map_elem_write_key__open_and_load"))
                for_each_map_elem_write_key__destroy(skel);
}

static void test_multi_maps(void)
{
        struct for_each_multi_maps *skel;
        __u64 val, array_total, hash_total;
        __u32 key, max_entries;
        int i, err;

        LIBBPF_OPTS(bpf_test_run_opts, topts,
                .data_in = &pkt_v4,
                .data_size_in = sizeof(pkt_v4),
                .repeat = 1,
        );

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

        array_total = 0;
        max_entries = bpf_map__max_entries(skel->maps.arraymap);
        for (i = 0; i < max_entries; i++) {
                key = i;
                val = i + 1;
                array_total += val;
                err = bpf_map__update_elem(skel->maps.arraymap, &key, sizeof(key),
                                           &val, sizeof(val), BPF_ANY);
                if (!ASSERT_OK(err, "array_map_update"))
                        goto out;
        }

        hash_total = 0;
        max_entries = bpf_map__max_entries(skel->maps.hashmap);
        for (i = 0; i < max_entries; i++) {
                key = i + 100;
                val = i + 1;
                hash_total += val;
                err = bpf_map__update_elem(skel->maps.hashmap, &key, sizeof(key),
                                           &val, sizeof(val), BPF_ANY);
                if (!ASSERT_OK(err, "hash_map_update"))
                        goto out;
        }

        skel->bss->data_output = 0;
        skel->bss->use_array = 1;
        err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_pkt_access), &topts);
        ASSERT_OK(err, "bpf_prog_test_run_opts");
        ASSERT_OK(topts.retval, "retval");
        ASSERT_EQ(skel->bss->data_output, array_total, "array output");

        skel->bss->data_output = 0;
        skel->bss->use_array = 0;
        err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_pkt_access), &topts);
        ASSERT_OK(err, "bpf_prog_test_run_opts");
        ASSERT_OK(topts.retval, "retval");
        ASSERT_EQ(skel->bss->data_output, hash_total, "hash output");

out:
        for_each_multi_maps__destroy(skel);
}

static void test_hash_modify(void)
{
        struct for_each_hash_modify *skel;
        int max_entries, i, err;
        __u64 key, val;

        LIBBPF_OPTS(bpf_test_run_opts, topts,
                .data_in = &pkt_v4,
                .data_size_in = sizeof(pkt_v4),
                .repeat = 1
        );

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

        max_entries = bpf_map__max_entries(skel->maps.hashmap);
        for (i = 0; i < max_entries; i++) {
                key = i;
                val = i;
                err = bpf_map__update_elem(skel->maps.hashmap, &key, sizeof(key),
                                           &val, sizeof(val), BPF_ANY);
                if (!ASSERT_OK(err, "map_update"))
                        goto out;
        }

        err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_pkt_access), &topts);
        ASSERT_OK(err, "bpf_prog_test_run_opts");
        ASSERT_OK(topts.retval, "retval");

out:
        for_each_hash_modify__destroy(skel);
}

void test_for_each(void)
{
        if (test__start_subtest("hash_map"))
                test_hash_map();
        if (test__start_subtest("array_map"))
                test_array_map();
        if (test__start_subtest("write_map_key"))
                test_write_map_key();
        if (test__start_subtest("multi_maps"))
                test_multi_maps();
        if (test__start_subtest("hash_modify"))
                test_hash_modify();
}