]>
Commit | Line | Data |
---|---|---|
a99ca6db JK |
1 | #include <errno.h> |
2 | #include <stdlib.h> | |
3 | #include <stdio.h> | |
4 | #include <string.h> | |
5 | #include <unistd.h> | |
2b279419 YS |
6 | #include <sys/time.h> |
7 | #include <sys/resource.h> | |
a99ca6db JK |
8 | |
9 | #include <linux/bpf.h> | |
10 | #include <linux/filter.h> | |
11 | #include <linux/unistd.h> | |
12 | ||
13 | #include <bpf/bpf.h> | |
14 | ||
15 | #define LOG_SIZE (1 << 20) | |
16 | ||
17 | #define err(str...) printf("ERROR: " str) | |
18 | ||
19 | static const struct bpf_insn code_sample[] = { | |
20 | /* We need a few instructions to pass the min log length */ | |
21 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
22 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
23 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
24 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
25 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
26 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
27 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
28 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
29 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
30 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
31 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
32 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
33 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
34 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
35 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
36 | BPF_MOV64_IMM(BPF_REG_0, 0), | |
37 | BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, | |
38 | BPF_FUNC_map_lookup_elem), | |
39 | BPF_EXIT_INSN(), | |
40 | }; | |
41 | ||
42 | static inline __u64 ptr_to_u64(const void *ptr) | |
43 | { | |
44 | return (__u64) (unsigned long) ptr; | |
45 | } | |
46 | ||
47 | static int load(char *log, size_t log_len, int log_level) | |
48 | { | |
49 | union bpf_attr attr; | |
50 | ||
51 | bzero(&attr, sizeof(attr)); | |
52 | attr.prog_type = BPF_PROG_TYPE_SOCKET_FILTER; | |
53 | attr.insn_cnt = (__u32)(sizeof(code_sample) / sizeof(struct bpf_insn)); | |
54 | attr.insns = ptr_to_u64(code_sample); | |
55 | attr.license = ptr_to_u64("GPL"); | |
56 | attr.log_buf = ptr_to_u64(log); | |
57 | attr.log_size = log_len; | |
58 | attr.log_level = log_level; | |
59 | ||
60 | return syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr)); | |
61 | } | |
62 | ||
63 | static void check_ret(int ret, int exp_errno) | |
64 | { | |
65 | if (ret > 0) { | |
66 | close(ret); | |
67 | err("broken sample loaded successfully!?\n"); | |
68 | exit(1); | |
69 | } | |
70 | ||
71 | if (!ret || errno != exp_errno) { | |
72 | err("Program load returned: ret:%d/errno:%d, expected ret:%d/errno:%d\n", | |
73 | ret, errno, -1, exp_errno); | |
74 | exit(1); | |
75 | } | |
76 | } | |
77 | ||
78 | static void check_ones(const char *buf, size_t len, const char *msg) | |
79 | { | |
80 | while (len--) | |
81 | if (buf[len] != 1) { | |
82 | err("%s", msg); | |
83 | exit(1); | |
84 | } | |
85 | } | |
86 | ||
87 | static void test_log_good(char *log, size_t buf_len, size_t log_len, | |
88 | size_t exp_len, int exp_errno, const char *full_log) | |
89 | { | |
90 | size_t len; | |
91 | int ret; | |
92 | ||
93 | memset(log, 1, buf_len); | |
94 | ||
95 | ret = load(log, log_len, 1); | |
96 | check_ret(ret, exp_errno); | |
97 | ||
98 | len = strnlen(log, buf_len); | |
99 | if (len == buf_len) { | |
100 | err("verifier did not NULL terminate the log\n"); | |
101 | exit(1); | |
102 | } | |
103 | if (exp_len && len != exp_len) { | |
104 | err("incorrect log length expected:%zd have:%zd\n", | |
105 | exp_len, len); | |
106 | exit(1); | |
107 | } | |
108 | ||
109 | if (strchr(log, 1)) { | |
110 | err("verifier leaked a byte through\n"); | |
111 | exit(1); | |
112 | } | |
113 | ||
114 | check_ones(log + len + 1, buf_len - len - 1, | |
115 | "verifier wrote bytes past NULL termination\n"); | |
116 | ||
117 | if (memcmp(full_log, log, LOG_SIZE)) { | |
118 | err("log did not match expected output\n"); | |
119 | exit(1); | |
120 | } | |
121 | } | |
122 | ||
123 | static void test_log_bad(char *log, size_t log_len, int log_level) | |
124 | { | |
125 | int ret; | |
126 | ||
127 | ret = load(log, log_len, log_level); | |
128 | check_ret(ret, EINVAL); | |
129 | if (log) | |
130 | check_ones(log, LOG_SIZE, | |
131 | "verifier touched log with bad parameters\n"); | |
132 | } | |
133 | ||
134 | int main(int argc, char **argv) | |
135 | { | |
2b279419 | 136 | struct rlimit limit = { RLIM_INFINITY, RLIM_INFINITY }; |
a99ca6db JK |
137 | char full_log[LOG_SIZE]; |
138 | char log[LOG_SIZE]; | |
139 | size_t want_len; | |
140 | int i; | |
141 | ||
2b279419 YS |
142 | /* allow unlimited locked memory to have more consistent error code */ |
143 | if (setrlimit(RLIMIT_MEMLOCK, &limit) < 0) | |
144 | perror("Unable to lift memlock rlimit"); | |
145 | ||
a99ca6db JK |
146 | memset(log, 1, LOG_SIZE); |
147 | ||
148 | /* Test incorrect attr */ | |
149 | printf("Test log_level 0...\n"); | |
150 | test_log_bad(log, LOG_SIZE, 0); | |
151 | ||
152 | printf("Test log_size < 128...\n"); | |
153 | test_log_bad(log, 15, 1); | |
154 | ||
155 | printf("Test log_buff = NULL...\n"); | |
156 | test_log_bad(NULL, LOG_SIZE, 1); | |
157 | ||
158 | /* Test with log big enough */ | |
159 | printf("Test oversized buffer...\n"); | |
160 | test_log_good(full_log, LOG_SIZE, LOG_SIZE, 0, EACCES, full_log); | |
161 | ||
162 | want_len = strlen(full_log); | |
163 | ||
164 | printf("Test exact buffer...\n"); | |
165 | test_log_good(log, LOG_SIZE, want_len + 2, want_len, EACCES, full_log); | |
166 | ||
167 | printf("Test undersized buffers...\n"); | |
168 | for (i = 0; i < 64; i++) { | |
169 | full_log[want_len - i + 1] = 1; | |
170 | full_log[want_len - i] = 0; | |
171 | ||
172 | test_log_good(log, LOG_SIZE, want_len + 1 - i, want_len - i, | |
173 | ENOSPC, full_log); | |
174 | } | |
175 | ||
176 | printf("test_verifier_log: OK\n"); | |
177 | return 0; | |
178 | } |