#include "ksym_race.skel.h"
 #include "bpf_mod_race.skel.h"
 #include "kfunc_call_race.skel.h"
+#include "testing_helpers.h"
 
 /* This test crafts a race between btf_try_get_module and do_init_module, and
  * checks whether btf_try_get_module handles the invocation for a well-formed
 
 static _Atomic enum bpf_test_state state = _TS_INVALID;
 
-static int sys_finit_module(int fd, const char *param_values, int flags)
-{
-       return syscall(__NR_finit_module, fd, param_values, flags);
-}
-
-static int sys_delete_module(const char *name, unsigned int flags)
-{
-       return syscall(__NR_delete_module, name, flags);
-}
-
-static int load_module(const char *mod)
-{
-       int ret, fd;
-
-       fd = open("bpf_testmod.ko", O_RDONLY);
-       if (fd < 0)
-               return fd;
-
-       ret = sys_finit_module(fd, "", 0);
-       close(fd);
-       if (ret < 0)
-               return ret;
-       return 0;
-}
-
 static void *load_module_thread(void *p)
 {
 
-       if (!ASSERT_NEQ(load_module("bpf_testmod.ko"), 0, "load_module_thread must fail"))
+       if (!ASSERT_NEQ(load_bpf_testmod(false), 0, "load_module_thread must fail"))
                atomic_store(&state, TS_MODULE_LOAD);
        else
                atomic_store(&state, TS_MODULE_LOAD_FAIL);
        if (!ASSERT_NEQ(fault_addr, MAP_FAILED, "mmap for uffd registration"))
                return;
 
-       if (!ASSERT_OK(sys_delete_module("bpf_testmod", 0), "unload bpf_testmod"))
+       if (!ASSERT_OK(unload_bpf_testmod(false), "unload bpf_testmod"))
                goto end_mmap;
 
        skel = bpf_mod_race__open();
        bpf_mod_race__destroy(skel);
        ASSERT_OK(kern_sync_rcu(), "kern_sync_rcu");
 end_module:
-       sys_delete_module("bpf_testmod", 0);
-       ASSERT_OK(load_module("bpf_testmod.ko"), "restore bpf_testmod");
+       unload_bpf_testmod(false);
+       ASSERT_OK(load_bpf_testmod(false), "restore bpf_testmod");
 end_mmap:
        munmap(fault_addr, 4096);
        atomic_store(&state, _TS_INVALID);
 
 #include <test_progs.h>
 #include <stdbool.h>
 #include "test_module_attach.skel.h"
+#include "testing_helpers.h"
 
 static int duration;
 
        return 0;
 }
 
-static int delete_module(const char *name, int flags)
-{
-       return syscall(__NR_delete_module, name, flags);
-}
-
 void test_module_attach(void)
 {
        const int READ_SZ = 456;
        if (!ASSERT_OK_PTR(link, "attach_fentry"))
                goto cleanup;
 
-       ASSERT_ERR(delete_module("bpf_testmod", 0), "delete_module");
+       ASSERT_ERR(unload_bpf_testmod(false), "unload_bpf_testmod");
        bpf_link__destroy(link);
 
        link = bpf_program__attach(skel->progs.handle_fexit);
        if (!ASSERT_OK_PTR(link, "attach_fexit"))
                goto cleanup;
 
-       ASSERT_ERR(delete_module("bpf_testmod", 0), "delete_module");
+       ASSERT_ERR(unload_bpf_testmod(false), "unload_bpf_testmod");
        bpf_link__destroy(link);
 
        link = bpf_program__attach(skel->progs.kprobe_multi);
        if (!ASSERT_OK_PTR(link, "attach_kprobe_multi"))
                goto cleanup;
 
-       ASSERT_ERR(delete_module("bpf_testmod", 0), "delete_module");
+       ASSERT_ERR(unload_bpf_testmod(false), "unload_bpf_testmod");
        bpf_link__destroy(link);
 
 cleanup:
 
        return syscall(__NR_delete_module, name, flags);
 }
 
-void unload_bpf_testmod(bool verbose)
+int unload_bpf_testmod(bool verbose)
 {
        if (kern_sync_rcu())
                fprintf(stdout, "Failed to trigger kernel-side RCU sync!\n");
                if (errno == ENOENT) {
                        if (verbose)
                                fprintf(stdout, "bpf_testmod.ko is already unloaded.\n");
-                       return;
+                       return -1;
                }
                fprintf(stdout, "Failed to unload bpf_testmod.ko from kernel: %d\n", -errno);
-               return;
+               return -1;
        }
        if (verbose)
                fprintf(stdout, "Successfully unloaded bpf_testmod.ko.\n");
+       return 0;
 }
 
 int load_bpf_testmod(bool verbose)