// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2021 Facebook */
#include <vmlinux.h>
#include <bpf/bpf_helpers.h>
#include "../test_kmods/bpf_testmod_kfunc.h"

struct syscall_test_args {
        __u8 data[16];
        size_t size;
};

SEC("?syscall")
int kfunc_syscall_test_fail(struct syscall_test_args *args)
{
        bpf_kfunc_call_test_mem_len_pass1(&args->data, sizeof(*args) + 1);

        return 0;
}

SEC("?syscall")
int kfunc_syscall_test_null_fail(struct syscall_test_args *args)
{
        /* Must be called with args as a NULL pointer
         * we do not check for it to have the verifier consider that
         * the pointer might not be null, and so we can load it.
         *
         * So the following can not be added:
         *
         * if (args)
         *      return -22;
         */

        bpf_kfunc_call_test_mem_len_pass1(args, sizeof(*args));

        return 0;
}

SEC("?tc")
int kfunc_call_test_get_mem_fail_rdonly(struct __sk_buff *skb)
{
        struct prog_test_ref_kfunc *pt;
        unsigned long s = 0;
        int *p = NULL;
        int ret = 0;

        pt = bpf_kfunc_call_test_acquire(&s);
        if (pt) {
                p = bpf_kfunc_call_test_get_rdonly_mem(pt, 2 * sizeof(int));
                if (p)
                        p[0] = 42; /* this is a read-only buffer, so -EACCES */
                else
                        ret = -1;

                bpf_kfunc_call_test_release(pt);
        }
        return ret;
}

SEC("?tc")
int kfunc_call_test_get_mem_fail_use_after_free(struct __sk_buff *skb)
{
        struct prog_test_ref_kfunc *pt;
        unsigned long s = 0;
        int *p = NULL;
        int ret = 0;

        pt = bpf_kfunc_call_test_acquire(&s);
        if (pt) {
                p = bpf_kfunc_call_test_get_rdwr_mem(pt, 2 * sizeof(int));
                if (p) {
                        p[0] = 42;
                        ret = p[1]; /* 108 */
                } else {
                        ret = -1;
                }

                bpf_kfunc_call_test_release(pt);
        }
        if (p)
                ret = p[0]; /* p is not valid anymore */

        return ret;
}

SEC("?tc")
int kfunc_call_test_get_mem_fail_oob(struct __sk_buff *skb)
{
        struct prog_test_ref_kfunc *pt;
        unsigned long s = 0;
        int *p = NULL;
        int ret = 0;

        pt = bpf_kfunc_call_test_acquire(&s);
        if (pt) {
                p = bpf_kfunc_call_test_get_rdonly_mem(pt, 2 * sizeof(int));
                if (p)
                        ret = p[2 * sizeof(int)]; /* oob access, so -EACCES */
                else
                        ret = -1;

                bpf_kfunc_call_test_release(pt);
        }
        return ret;
}

int not_const_size = 2 * sizeof(int);

SEC("?tc")
int kfunc_call_test_get_mem_fail_not_const(struct __sk_buff *skb)
{
        struct prog_test_ref_kfunc *pt;
        unsigned long s = 0;
        int *p = NULL;
        int ret = 0;

        pt = bpf_kfunc_call_test_acquire(&s);
        if (pt) {
                p = bpf_kfunc_call_test_get_rdonly_mem(pt, not_const_size); /* non const size, -EINVAL */
                if (p)
                        ret = p[0];
                else
                        ret = -1;

                bpf_kfunc_call_test_release(pt);
        }
        return ret;
}

SEC("?tc")
int kfunc_call_test_mem_acquire_fail(struct __sk_buff *skb)
{
        struct prog_test_ref_kfunc *pt;
        unsigned long s = 0;
        int *p = NULL;
        int ret = 0;

        pt = bpf_kfunc_call_test_acquire(&s);
        if (pt) {
                /* we are failing on this one, because we are not acquiring a PTR_TO_BTF_ID (a struct ptr) */
                p = bpf_kfunc_call_test_acq_rdonly_mem(pt, 2 * sizeof(int));
                if (p)
                        ret = p[0];
                else
                        ret = -1;

                bpf_kfunc_call_int_mem_release(p);

                bpf_kfunc_call_test_release(pt);
        }
        return ret;
}

SEC("?tc")
int kfunc_call_test_pointer_arg_type_mismatch(struct __sk_buff *skb)
{
        bpf_kfunc_call_test_pass_ctx((void *)10);
        return 0;
}

char _license[] SEC("license") = "GPL";