free_fds(est_fds, nr_est);
 }
 
-void test_bpf_iter_setsockopt(void)
+void serial_test_bpf_iter_setsockopt(void)
 {
        struct bpf_iter_setsockopt *iter_skel = NULL;
        struct bpf_cubic *cubic_skel = NULL;
 
 
 #define nr_iters 2
 
-void test_bpf_obj_id(void)
+void serial_test_bpf_obj_id(void)
 {
        const __u64 array_magic_value = 0xfaceb00c;
        const __u32 array_key = 0;
 
        cg_storage_multi_shared__destroy(obj);
 }
 
-void test_cg_storage_multi(void)
+void serial_test_cg_storage_multi(void)
 {
        int parent_cgroup_fd = -1, child_cgroup_fd = -1;
 
 
                               bpf_log_buf, BPF_LOG_BUF_SIZE);
 }
 
-void test_cgroup_attach_autodetach(void)
+void serial_test_cgroup_attach_autodetach(void)
 {
        __u32 duration = 0, prog_cnt = 4, attach_flags;
        int allow_prog[2] = {-1};
 
        return ret;
 }
 
-void test_cgroup_attach_multi(void)
+void serial_test_cgroup_attach_multi(void)
 {
        __u32 prog_ids[4], prog_cnt = 0, attach_flags, saved_prog_id;
        int cg1 = 0, cg2 = 0, cg3 = 0, cg4 = 0, cg5 = 0, key = 0;
 
                               bpf_log_buf, BPF_LOG_BUF_SIZE);
 }
 
-void test_cgroup_attach_override(void)
+void serial_test_cgroup_attach_override(void)
 {
        int drop_prog = -1, allow_prog = -1, foo = -1, bar = -1;
        __u32 duration = 0;
 
        return 0;
 }
 
-void test_cgroup_link(void)
+void serial_test_cgroup_link(void)
 {
        struct {
                const char *path;
 
        test_check_mtu__destroy(skel);
 }
 
-void test_check_mtu(void)
+void serial_test_check_mtu(void)
 {
        __u32 mtu_lo;
 
 
                                     "./test_attach_probe.o");
 }
 
-void test_fexit_bpf2bpf(void)
+/* NOTE: affect other tests, must run in serial mode */
+void serial_test_fexit_bpf2bpf(void)
 {
        if (test__start_subtest("target_no_callees"))
                test_target_no_callees();
 
 #include <test_progs.h>
 #include <network_helpers.h>
 
-void test_flow_dissector_load_bytes(void)
+void serial_test_flow_dissector_load_bytes(void)
 {
        struct bpf_flow_keys flow_keys;
        __u32 duration = 0, retval, size;
 
        }
 }
 
-void test_flow_dissector_reattach(void)
+void serial_test_flow_dissector_reattach(void)
 {
        int err, new_net, saved_net;
 
 
        free(pfd_array);
 }
 
-void test_get_branch_snapshot(void)
+void serial_test_get_branch_snapshot(void)
 {
        struct get_branch_snapshot *skel = NULL;
        int err;
 
        *(bool *)ctx = true;
 }
 
-void test_kfree_skb(void)
+/* TODO: fix kernel panic caused by this test in parallel mode */
+void serial_test_kfree_skb(void)
 {
        struct __sk_buff skb = {};
        struct bpf_prog_test_run_attr tattr = {
 
        }
 }
 
-void test_migrate_reuseport(void)
+void serial_test_migrate_reuseport(void)
 {
        struct test_migrate_reuseport *skel;
        int i;
 
        modify_return__destroy(skel);
 }
 
-void test_modify_return(void)
+/* TODO: conflict with get_func_ip_test */
+void serial_test_modify_return(void)
 {
        run_test(0 /* input_retval */,
                 1 /* want_side_effect */,
 
                return;
 }
 
-void test_ns_current_pid_tgid(void)
+/* TODO: use a different tracepoint */
+void serial_test_ns_current_pid_tgid(void)
 {
        if (test__start_subtest("ns_current_pid_tgid_root_ns"))
                test_current_pid_tgid(NULL);
 
        return 0;
 }
 
-void test_perf_buffer(void)
+void serial_test_perf_buffer(void)
 {
        int err, on_len, nr_on_cpus = 0, nr_cpus, i;
        struct perf_buffer_opts pb_opts = {};
 
                ++j;
 }
 
-void test_perf_link(void)
+/* TODO: often fails in concurrent mode */
+void serial_test_perf_link(void)
 {
        struct test_perf_link *skel = NULL;
        struct perf_event_attr attr;
 
 // SPDX-License-Identifier: GPL-2.0
 #include <test_progs.h>
 
-void test_probe_user(void)
+/* TODO: corrupts other tests uses connect() */
+void serial_test_probe_user(void)
 {
        const char *prog_name = "handle_sys_connect";
        const char *obj_file = "./test_probe_user.o";
 
 #include <test_progs.h>
 #include <linux/nbd.h>
 
-void test_raw_tp_writable_test_run(void)
+/* NOTE: conflict with other tests. */
+void serial_test_raw_tp_writable_test_run(void)
 {
        __u32 duration = 0;
        char error[4096];
 
        cleanup();
 }
 
-void test_select_reuseport(void)
+void serial_test_select_reuseport(void)
 {
        saved_tcp_fo = read_int_sysctl(TCP_FO_SYSCTL);
        if (saved_tcp_fo < 0)
 
        return NULL;
 }
 
-void test_send_signal_sched_switch(void)
+/* NOTE: cause events loss */
+void serial_test_send_signal_sched_switch(void)
 {
        struct test_send_signal_kern *skel;
        pthread_t threads[THREAD_COUNT];
 
                close(listen_fd);
 }
 
-void test_sk_storage_tracing(void)
+void serial_test_sk_storage_tracing(void)
 {
        struct test_sk_storage_trace_itself *skel_itself;
        int err;
 
 /* Demonstrate that bpf_snprintf_btf succeeds and that various data types
  * are formatted correctly.
  */
-void test_snprintf_btf(void)
+void serial_test_snprintf_btf(void)
 {
        struct netif_receive_skb *skel;
        struct netif_receive_skb__bss *bss;
 
                close(listen_fd);
 }
 
-void test_sock_fields(void)
+void serial_test_sock_fields(void)
 {
        struct bpf_link *egress_link = NULL, *ingress_link = NULL;
        int parent_cg_fd = -1, child_cg_fd = -1;
 
        test_udp_unix_redir(skel, map, family);
 }
 
-void test_sockmap_listen(void)
+void serial_test_sockmap_listen(void)
 {
        struct test_sockmap_listen *skel;
 
 
        return 0;
 }
 
-void test_timer(void)
+/* TODO: use pid filtering */
+void serial_test_timer(void)
 {
        struct timer *timer_skel = NULL;
        int err;
 
        return 0;
 }
 
-void test_timer_mim(void)
+void serial_test_timer_mim(void)
 {
        struct timer_mim_reject *timer_reject_skel = NULL;
        libbpf_print_fn_t old_print_fn = NULL;
 
 // SPDX-License-Identifier: GPL-2.0
 #include <test_progs.h>
 
-void test_tp_attach_query(void)
+void serial_test_tp_attach_query(void)
 {
        const int num_progs = 3;
        int i, j, bytes, efd, err, prog_fd[num_progs], pmu_fd[num_progs];
 
 #define TRACEBUF       "/sys/kernel/debug/tracing/trace_pipe"
 #define SEARCHMSG      "testing,testing"
 
-void test_trace_printk(void)
+void serial_test_trace_printk(void)
 {
        int err = 0, iter = 0, found = 0;
        struct trace_printk__bss *bss;
 
 #define TRACEBUF       "/sys/kernel/debug/tracing/trace_pipe"
 #define SEARCHMSG      "1,2,3,4,5,6,7,8,9,10"
 
-void test_trace_vprintk(void)
+void serial_test_trace_vprintk(void)
 {
        int err = 0, iter = 0, found = 0;
        struct trace_vprintk__bss *bss;
 
        return bpf_program__attach_trace(prog);
 }
 
-void test_trampoline_count(void)
+/* TODO: use different target function to run in concurrent mode */
+void serial_test_trampoline_count(void)
 {
        const char *fentry_name = "fentry/__set_task_comm";
        const char *fexit_name = "fexit/__set_task_comm";
 
 #define IFINDEX_LO 1
 #define XDP_FLAGS_REPLACE              (1U << 4)
 
-void test_xdp_attach(void)
+void serial_test_xdp_attach(void)
 {
        __u32 duration = 0, id1, id2, id0 = 0, len;
        struct bpf_object *obj1, *obj2, *obj3;
 
        { "xdp_bonding_xor_layer34", BOND_MODE_XOR, BOND_XMIT_POLICY_LAYER34, },
 };
 
-void test_xdp_bonding(void)
+void serial_test_xdp_bonding(void)
 {
        libbpf_print_fn_t old_print_fn;
        struct skeletons skeletons = {};
 
 
 #define IFINDEX_LO     1
 
-void test_xdp_cpumap_attach(void)
+void serial_test_xdp_cpumap_attach(void)
 {
        struct test_xdp_with_cpumap_helpers *skel;
        struct bpf_prog_info info = {};
 
 }
 
 
-void test_xdp_devmap_attach(void)
+void serial_test_xdp_devmap_attach(void)
 {
        if (test__start_subtest("DEVMAP with programs in entries"))
                test_xdp_with_devmap_helpers();
 
 
 #define IFINDEX_LO 1
 
-void test_xdp_info(void)
+void serial_test_xdp_info(void)
 {
        __u32 len = sizeof(struct bpf_prog_info), duration = 0, prog_id;
        const char *file = "./xdp_dummy.o";
 
 
 #define IFINDEX_LO 1
 
-void test_xdp_link(void)
+void serial_test_xdp_link(void)
 {
        __u32 duration = 0, id1, id2, id0 = 0, prog_fd1, prog_fd2, err;
        DECLARE_LIBBPF_OPTS(bpf_xdp_set_link_opts, opts, .old_fd = -1);