// SPDX-License-Identifier: GPL-2.0
/* Copyright (C) 2025. Huawei Technologies Co., Ltd */
#define _GNU_SOURCE
#include <unistd.h>
#include <sys/syscall.h>
#include <test_progs.h>

#include "free_timer.skel.h"

struct run_ctx {
        struct bpf_program *start_prog;
        struct bpf_program *overwrite_prog;
        pthread_barrier_t notify;
        int loop;
        bool start;
        bool stop;
};

static void start_threads(struct run_ctx *ctx)
{
        ctx->start = true;
}

static void stop_threads(struct run_ctx *ctx)
{
        ctx->stop = true;
        /* Guarantee the order between ->stop and ->start */
        __atomic_store_n(&ctx->start, true, __ATOMIC_RELEASE);
}

static int wait_for_start(struct run_ctx *ctx)
{
        while (!__atomic_load_n(&ctx->start, __ATOMIC_ACQUIRE))
                usleep(10);

        return ctx->stop;
}

static void *overwrite_timer_fn(void *arg)
{
        struct run_ctx *ctx = arg;
        int loop, fd, err;
        cpu_set_t cpuset;
        long ret = 0;

        /* Pin on CPU 0 */
        CPU_ZERO(&cpuset);
        CPU_SET(0, &cpuset);
        pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);

        /* Is the thread being stopped ? */
        err = wait_for_start(ctx);
        if (err)
                return NULL;

        fd = bpf_program__fd(ctx->overwrite_prog);
        loop = ctx->loop;
        while (loop-- > 0) {
                LIBBPF_OPTS(bpf_test_run_opts, opts);

                /* Wait for start thread to complete */
                pthread_barrier_wait(&ctx->notify);

                /* Overwrite timers */
                err = bpf_prog_test_run_opts(fd, &opts);
                if (err)
                        ret |= 1;
                else if (opts.retval)
                        ret |= 2;

                /* Notify start thread to start timers */
                pthread_barrier_wait(&ctx->notify);
        }

        return (void *)ret;
}

static void *start_timer_fn(void *arg)
{
        struct run_ctx *ctx = arg;
        int loop, fd, err;
        cpu_set_t cpuset;
        long ret = 0;

        /* Pin on CPU 1 */
        CPU_ZERO(&cpuset);
        CPU_SET(1, &cpuset);
        pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);

        /* Is the thread being stopped ? */
        err = wait_for_start(ctx);
        if (err)
                return NULL;

        fd = bpf_program__fd(ctx->start_prog);
        loop = ctx->loop;
        while (loop-- > 0) {
                LIBBPF_OPTS(bpf_test_run_opts, opts);

                /* Run the prog to start timer */
                err = bpf_prog_test_run_opts(fd, &opts);
                if (err)
                        ret |= 4;
                else if (opts.retval)
                        ret |= 8;

                /* Notify overwrite thread to do overwrite */
                pthread_barrier_wait(&ctx->notify);

                /* Wait for overwrite thread to complete */
                pthread_barrier_wait(&ctx->notify);
        }

        return (void *)ret;
}

void test_free_timer(void)
{
        struct free_timer *skel;
        struct bpf_program *prog;
        struct run_ctx ctx;
        pthread_t tid[2];
        void *ret;
        int err;

        skel = free_timer__open_and_load();
        if (!skel && errno == EOPNOTSUPP) {
                test__skip();
                return;
        }
        if (!ASSERT_OK_PTR(skel, "open_load"))
                return;

        memset(&ctx, 0, sizeof(ctx));

        prog = bpf_object__find_program_by_name(skel->obj, "start_timer");
        if (!ASSERT_OK_PTR(prog, "find start prog"))
                goto out;
        ctx.start_prog = prog;

        prog = bpf_object__find_program_by_name(skel->obj, "overwrite_timer");
        if (!ASSERT_OK_PTR(prog, "find overwrite prog"))
                goto out;
        ctx.overwrite_prog = prog;

        pthread_barrier_init(&ctx.notify, NULL, 2);
        ctx.loop = 10;

        err = pthread_create(&tid[0], NULL, start_timer_fn, &ctx);
        if (!ASSERT_OK(err, "create start_timer"))
                goto out;

        err = pthread_create(&tid[1], NULL, overwrite_timer_fn, &ctx);
        if (!ASSERT_OK(err, "create overwrite_timer")) {
                stop_threads(&ctx);
                goto out;
        }

        start_threads(&ctx);

        ret = NULL;
        err = pthread_join(tid[0], &ret);
        ASSERT_EQ(err | (long)ret, 0, "start_timer");
        ret = NULL;
        err = pthread_join(tid[1], &ret);
        ASSERT_EQ(err | (long)ret, 0, "overwrite_timer");
out:
        free_timer__destroy(skel);
}