bpf/prog_tests/section_names.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 // Copyright (c) 2018 Facebook
0003 #include <test_progs.h>
0004
0005 static int duration = 0;
0006
0007 struct sec_name_test {
0008     const char sec_name[32];
0009     struct {
0010         int rc;
0011         enum bpf_prog_type prog_type;
0012         enum bpf_attach_type expected_attach_type;
0013     } expected_load;
0014     struct {
0015         int rc;
0016         enum bpf_attach_type attach_type;
0017     } expected_attach;
0018 };
0019
0020 static struct sec_name_test tests[] = {
0021     {"InvAliD", {-ESRCH, 0, 0}, {-EINVAL, 0} },
0022     {"cgroup", {-ESRCH, 0, 0}, {-EINVAL, 0} },
0023     {"socket", {0, BPF_PROG_TYPE_SOCKET_FILTER, 0}, {-EINVAL, 0} },
0024     {"kprobe/", {0, BPF_PROG_TYPE_KPROBE, 0}, {-EINVAL, 0} },
0025     {"uprobe/", {0, BPF_PROG_TYPE_KPROBE, 0}, {-EINVAL, 0} },
0026     {"kretprobe/", {0, BPF_PROG_TYPE_KPROBE, 0}, {-EINVAL, 0} },
0027     {"uretprobe/", {0, BPF_PROG_TYPE_KPROBE, 0}, {-EINVAL, 0} },
0028     {"classifier", {0, BPF_PROG_TYPE_SCHED_CLS, 0}, {-EINVAL, 0} },
0029     {"action", {0, BPF_PROG_TYPE_SCHED_ACT, 0}, {-EINVAL, 0} },
0030     {"tracepoint/", {0, BPF_PROG_TYPE_TRACEPOINT, 0}, {-EINVAL, 0} },
0031     {"tp/", {0, BPF_PROG_TYPE_TRACEPOINT, 0}, {-EINVAL, 0} },
0032     {
0033         "raw_tracepoint/",
0034         {0, BPF_PROG_TYPE_RAW_TRACEPOINT, 0},
0035         {-EINVAL, 0},
0036     },
0037     {"raw_tp/", {0, BPF_PROG_TYPE_RAW_TRACEPOINT, 0}, {-EINVAL, 0} },
0038     {"xdp", {0, BPF_PROG_TYPE_XDP, BPF_XDP}, {0, BPF_XDP} },
0039     {"perf_event", {0, BPF_PROG_TYPE_PERF_EVENT, 0}, {-EINVAL, 0} },
0040     {"lwt_in", {0, BPF_PROG_TYPE_LWT_IN, 0}, {-EINVAL, 0} },
0041     {"lwt_out", {0, BPF_PROG_TYPE_LWT_OUT, 0}, {-EINVAL, 0} },
0042     {"lwt_xmit", {0, BPF_PROG_TYPE_LWT_XMIT, 0}, {-EINVAL, 0} },
0043     {"lwt_seg6local", {0, BPF_PROG_TYPE_LWT_SEG6LOCAL, 0}, {-EINVAL, 0} },
0044     {
0045         "cgroup_skb/ingress",
0046         {0, BPF_PROG_TYPE_CGROUP_SKB, BPF_CGROUP_INET_INGRESS},
0047         {0, BPF_CGROUP_INET_INGRESS},
0048     },
0049     {
0050         "cgroup_skb/egress",
0051         {0, BPF_PROG_TYPE_CGROUP_SKB, BPF_CGROUP_INET_EGRESS},
0052         {0, BPF_CGROUP_INET_EGRESS},
0053     },
0054     {"cgroup/skb", {0, BPF_PROG_TYPE_CGROUP_SKB, 0}, {-EINVAL, 0} },
0055     {
0056         "cgroup/sock",
0057         {0, BPF_PROG_TYPE_CGROUP_SOCK, BPF_CGROUP_INET_SOCK_CREATE},
0058         {0, BPF_CGROUP_INET_SOCK_CREATE},
0059     },
0060     {
0061         "cgroup/post_bind4",
0062         {0, BPF_PROG_TYPE_CGROUP_SOCK, BPF_CGROUP_INET4_POST_BIND},
0063         {0, BPF_CGROUP_INET4_POST_BIND},
0064     },
0065     {
0066         "cgroup/post_bind6",
0067         {0, BPF_PROG_TYPE_CGROUP_SOCK, BPF_CGROUP_INET6_POST_BIND},
0068         {0, BPF_CGROUP_INET6_POST_BIND},
0069     },
0070     {
0071         "cgroup/dev",
0072         {0, BPF_PROG_TYPE_CGROUP_DEVICE, BPF_CGROUP_DEVICE},
0073         {0, BPF_CGROUP_DEVICE},
0074     },
0075     {
0076         "sockops",
0077         {0, BPF_PROG_TYPE_SOCK_OPS, BPF_CGROUP_SOCK_OPS},
0078         {0, BPF_CGROUP_SOCK_OPS},
0079     },
0080     {
0081         "sk_skb/stream_parser",
0082         {0, BPF_PROG_TYPE_SK_SKB, BPF_SK_SKB_STREAM_PARSER},
0083         {0, BPF_SK_SKB_STREAM_PARSER},
0084     },
0085     {
0086         "sk_skb/stream_verdict",
0087         {0, BPF_PROG_TYPE_SK_SKB, BPF_SK_SKB_STREAM_VERDICT},
0088         {0, BPF_SK_SKB_STREAM_VERDICT},
0089     },
0090     {"sk_skb", {0, BPF_PROG_TYPE_SK_SKB, 0}, {-EINVAL, 0} },
0091     {
0092         "sk_msg",
0093         {0, BPF_PROG_TYPE_SK_MSG, BPF_SK_MSG_VERDICT},
0094         {0, BPF_SK_MSG_VERDICT},
0095     },
0096     {
0097         "lirc_mode2",
0098         {0, BPF_PROG_TYPE_LIRC_MODE2, BPF_LIRC_MODE2},
0099         {0, BPF_LIRC_MODE2},
0100     },
0101     {
0102         "flow_dissector",
0103         {0, BPF_PROG_TYPE_FLOW_DISSECTOR, BPF_FLOW_DISSECTOR},
0104         {0, BPF_FLOW_DISSECTOR},
0105     },
0106     {
0107         "cgroup/bind4",
0108         {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET4_BIND},
0109         {0, BPF_CGROUP_INET4_BIND},
0110     },
0111     {
0112         "cgroup/bind6",
0113         {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET6_BIND},
0114         {0, BPF_CGROUP_INET6_BIND},
0115     },
0116     {
0117         "cgroup/connect4",
0118         {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET4_CONNECT},
0119         {0, BPF_CGROUP_INET4_CONNECT},
0120     },
0121     {
0122         "cgroup/connect6",
0123         {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_INET6_CONNECT},
0124         {0, BPF_CGROUP_INET6_CONNECT},
0125     },
0126     {
0127         "cgroup/sendmsg4",
0128         {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_UDP4_SENDMSG},
0129         {0, BPF_CGROUP_UDP4_SENDMSG},
0130     },
0131     {
0132         "cgroup/sendmsg6",
0133         {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_UDP6_SENDMSG},
0134         {0, BPF_CGROUP_UDP6_SENDMSG},
0135     },
0136     {
0137         "cgroup/recvmsg4",
0138         {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_UDP4_RECVMSG},
0139         {0, BPF_CGROUP_UDP4_RECVMSG},
0140     },
0141     {
0142         "cgroup/recvmsg6",
0143         {0, BPF_PROG_TYPE_CGROUP_SOCK_ADDR, BPF_CGROUP_UDP6_RECVMSG},
0144         {0, BPF_CGROUP_UDP6_RECVMSG},
0145     },
0146     {
0147         "cgroup/sysctl",
0148         {0, BPF_PROG_TYPE_CGROUP_SYSCTL, BPF_CGROUP_SYSCTL},
0149         {0, BPF_CGROUP_SYSCTL},
0150     },
0151     {
0152         "cgroup/getsockopt",
0153         {0, BPF_PROG_TYPE_CGROUP_SOCKOPT, BPF_CGROUP_GETSOCKOPT},
0154         {0, BPF_CGROUP_GETSOCKOPT},
0155     },
0156     {
0157         "cgroup/setsockopt",
0158         {0, BPF_PROG_TYPE_CGROUP_SOCKOPT, BPF_CGROUP_SETSOCKOPT},
0159         {0, BPF_CGROUP_SETSOCKOPT},
0160     },
0161 };
0162
0163 static void test_prog_type_by_name(const struct sec_name_test *test)
0164 {
0165     enum bpf_attach_type expected_attach_type;
0166     enum bpf_prog_type prog_type;
0167     int rc;
0168
0169     rc = libbpf_prog_type_by_name(test->sec_name, &prog_type,
0170                       &expected_attach_type);
0171
0172     CHECK(rc != test->expected_load.rc, "check_code",
0173           "prog: unexpected rc=%d for %s\n", rc, test->sec_name);
0174
0175     if (rc)
0176         return;
0177
0178     CHECK(prog_type != test->expected_load.prog_type, "check_prog_type",
0179           "prog: unexpected prog_type=%d for %s\n",
0180           prog_type, test->sec_name);
0181
0182     CHECK(expected_attach_type != test->expected_load.expected_attach_type,
0183           "check_attach_type", "prog: unexpected expected_attach_type=%d for %s\n",
0184           expected_attach_type, test->sec_name);
0185 }
0186
0187 static void test_attach_type_by_name(const struct sec_name_test *test)
0188 {
0189     enum bpf_attach_type attach_type;
0190     int rc;
0191
0192     rc = libbpf_attach_type_by_name(test->sec_name, &attach_type);
0193
0194     CHECK(rc != test->expected_attach.rc, "check_ret",
0195           "attach: unexpected rc=%d for %s\n", rc, test->sec_name);
0196
0197     if (rc)
0198         return;
0199
0200     CHECK(attach_type != test->expected_attach.attach_type,
0201           "check_attach_type", "attach: unexpected attach_type=%d for %s\n",
0202           attach_type, test->sec_name);
0203 }
0204
0205 void test_section_names(void)
0206 {
0207     int i;
0208
0209     for (i = 0; i < ARRAY_SIZE(tests); ++i) {
0210         struct sec_name_test *test = &tests[i];
0211
0212         test_prog_type_by_name(test);
0213         test_attach_type_by_name(test);
0214     }
0215 }