// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2023 Meta Platforms, Inc. and affiliates. */

#include <errno.h>
#include <sys/syscall.h>
#include <unistd.h>

#include "test_map_ops.skel.h"
#include "test_progs.h"

static void map_update(void)
{
        (void)syscall(__NR_getpid);
}

static void map_delete(void)
{
        (void)syscall(__NR_getppid);
}

static void map_push(void)
{
        (void)syscall(__NR_getuid);
}

static void map_pop(void)
{
        (void)syscall(__NR_geteuid);
}

static void map_peek(void)
{
        (void)syscall(__NR_getgid);
}

static void map_for_each_pass(void)
{
        (void)syscall(__NR_gettid);
}

static void map_for_each_fail(void)
{
        (void)syscall(__NR_getpgid);
}

static int setup(struct test_map_ops **skel)
{
        int err = 0;

        if (!skel)
                return -1;

        *skel = test_map_ops__open();
        if (!ASSERT_OK_PTR(*skel, "test_map_ops__open"))
                return -1;

        (*skel)->rodata->pid = getpid();

        err = test_map_ops__load(*skel);
        if (!ASSERT_OK(err, "test_map_ops__load"))
                return err;

        err = test_map_ops__attach(*skel);
        if (!ASSERT_OK(err, "test_map_ops__attach"))
                return err;

        return err;
}

static void teardown(struct test_map_ops **skel)
{
        if (skel && *skel)
                test_map_ops__destroy(*skel);
}

static void map_ops_update_delete_subtest(void)
{
        struct test_map_ops *skel;

        if (setup(&skel))
                goto teardown;

        map_update();
        ASSERT_OK(skel->bss->err, "map_update_initial");

        map_update();
        ASSERT_LT(skel->bss->err, 0, "map_update_existing");
        ASSERT_EQ(skel->bss->err, -EEXIST, "map_update_existing");

        map_delete();
        ASSERT_OK(skel->bss->err, "map_delete_existing");

        map_delete();
        ASSERT_LT(skel->bss->err, 0, "map_delete_non_existing");
        ASSERT_EQ(skel->bss->err, -ENOENT, "map_delete_non_existing");

teardown:
        teardown(&skel);
}

static void map_ops_push_peek_pop_subtest(void)
{
        struct test_map_ops *skel;

        if (setup(&skel))
                goto teardown;

        map_push();
        ASSERT_OK(skel->bss->err, "map_push_initial");

        map_push();
        ASSERT_LT(skel->bss->err, 0, "map_push_when_full");
        ASSERT_EQ(skel->bss->err, -E2BIG, "map_push_when_full");

        map_peek();
        ASSERT_OK(skel->bss->err, "map_peek");

        map_pop();
        ASSERT_OK(skel->bss->err, "map_pop");

        map_peek();
        ASSERT_LT(skel->bss->err, 0, "map_peek_when_empty");
        ASSERT_EQ(skel->bss->err, -ENOENT, "map_peek_when_empty");

        map_pop();
        ASSERT_LT(skel->bss->err, 0, "map_pop_when_empty");
        ASSERT_EQ(skel->bss->err, -ENOENT, "map_pop_when_empty");

teardown:
        teardown(&skel);
}

static void map_ops_for_each_subtest(void)
{
        struct test_map_ops *skel;

        if (setup(&skel))
                goto teardown;

        map_for_each_pass();
        /* expect to iterate over 1 element */
        ASSERT_EQ(skel->bss->err, 1, "map_for_each_no_flags");

        map_for_each_fail();
        ASSERT_LT(skel->bss->err, 0, "map_for_each_with_flags");
        ASSERT_EQ(skel->bss->err, -EINVAL, "map_for_each_with_flags");

teardown:
        teardown(&skel);
}

void test_map_ops(void)
{
        if (test__start_subtest("map_ops_update_delete"))
                map_ops_update_delete_subtest();

        if (test__start_subtest("map_ops_push_peek_pop"))
                map_ops_push_peek_pop_subtest();

        if (test__start_subtest("map_ops_for_each"))
                map_ops_for_each_subtest();
}