1 /* 2 * Strictly speaking, this is not a test. But it can report during test 3 * runs so relative performace can be measured. 4 */ 5 #define _GNU_SOURCE 6 #include <assert.h> 7 #include <limits.h> 8 #include <stdbool.h> 9 #include <stddef.h> 10 #include <stdio.h> 11 #include <stdlib.h> 12 #include <time.h> 13 #include <unistd.h> 14 #include <linux/filter.h> 15 #include <linux/seccomp.h> 16 #include <sys/param.h> 17 #include <sys/prctl.h> 18 #include <sys/syscall.h> 19 #include <sys/types.h> 20 21 #include "../kselftest.h" 22 23 unsigned long long timing(clockid_t clk_id, unsigned long long samples) 24 { 25 struct timespec start, finish; 26 unsigned long long i; 27 pid_t pid, ret; 28 29 pid = getpid(); 30 assert(clock_gettime(clk_id, &start) == 0); 31 for (i = 0; i < samples; i++) { 32 ret = syscall(__NR_getpid); 33 assert(pid == ret); 34 } 35 assert(clock_gettime(clk_id, &finish) == 0); 36 37 i = finish.tv_sec - start.tv_sec; 38 i *= 1000000000ULL; 39 i += finish.tv_nsec - start.tv_nsec; 40 41 printf("%lu.%09lu - %lu.%09lu = %llu (%.1fs)\n", 42 finish.tv_sec, finish.tv_nsec, 43 start.tv_sec, start.tv_nsec, 44 i, (double)i / 1000000000.0); 45 46 return i; 47 } 48 49 unsigned long long calibrate(void) 50 { 51 struct timespec start, finish; 52 unsigned long long i, samples, step = 9973; 53 pid_t pid, ret; 54 int seconds = 15; 55 56 printf("Calibrating sample size for %d seconds worth of syscalls ...\n", seconds); 57 58 samples = 0; 59 pid = getpid(); 60 assert(clock_gettime(CLOCK_MONOTONIC, &start) == 0); 61 do { 62 for (i = 0; i < step; i++) { 63 ret = syscall(__NR_getpid); 64 assert(pid == ret); 65 } 66 assert(clock_gettime(CLOCK_MONOTONIC, &finish) == 0); 67 68 samples += step; 69 i = finish.tv_sec - start.tv_sec; 70 i *= 1000000000ULL; 71 i += finish.tv_nsec - start.tv_nsec; 72 } while (i < 1000000000ULL); 73 74 return samples * seconds; 75 } 76 77 bool approx(int i_one, int i_two) 78 { 79 double one = i_one, one_bump = one * 0.01; 80 double two = i_two, two_bump = two * 0.01; 81 82 one_bump = one + MAX(one_bump, 2.0); 83 two_bump = two + MAX(two_bump, 2.0); 84 85 /* Equal to, or within 1% or 2 digits */ 86 if (one == two || 87 (one > two && one <= two_bump) || 88 (two > one && two <= one_bump)) 89 return true; 90 return false; 91 } 92 93 bool le(int i_one, int i_two) 94 { 95 if (i_one <= i_two) 96 return true; 97 return false; 98 } 99 100 long compare(const char *name_one, const char *name_eval, const char *name_two, 101 unsigned long long one, bool (*eval)(int, int), unsigned long long two) 102 { 103 bool good; 104 105 printf("\t%s %s %s (%lld %s %lld): ", name_one, name_eval, name_two, 106 (long long)one, name_eval, (long long)two); 107 if (one > INT_MAX) { 108 printf("Miscalculation! Measurement went negative: %lld\n", (long long)one); 109 return 1; 110 } 111 if (two > INT_MAX) { 112 printf("Miscalculation! Measurement went negative: %lld\n", (long long)two); 113 return 1; 114 } 115 116 good = eval(one, two); 117 printf("%s\n", good ? "✔️" : "❌"); 118 119 return good ? 0 : 1; 120 } 121 122 int main(int argc, char *argv[]) 123 { 124 struct sock_filter bitmap_filter[] = { 125 BPF_STMT(BPF_LD|BPF_W|BPF_ABS, offsetof(struct seccomp_data, nr)), 126 BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_ALLOW), 127 }; 128 struct sock_fprog bitmap_prog = { 129 .len = (unsigned short)ARRAY_SIZE(bitmap_filter), 130 .filter = bitmap_filter, 131 }; 132 struct sock_filter filter[] = { 133 BPF_STMT(BPF_LD|BPF_W|BPF_ABS, offsetof(struct seccomp_data, args[0])), 134 BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_ALLOW), 135 }; 136 struct sock_fprog prog = { 137 .len = (unsigned short)ARRAY_SIZE(filter), 138 .filter = filter, 139 }; 140 141 long ret, bits; 142 unsigned long long samples, calc; 143 unsigned long long native, filter1, filter2, bitmap1, bitmap2; 144 unsigned long long entry, per_filter1, per_filter2; 145 146 setbuf(stdout, NULL); 147 148 printf("Running on:\n"); 149 system("uname -a"); 150 151 printf("Current BPF sysctl settings:\n"); 152 /* Avoid using "sysctl" which may not be installed. */ 153 system("grep -H . /proc/sys/net/core/bpf_jit_enable"); 154 system("grep -H . /proc/sys/net/core/bpf_jit_harden"); 155 156 if (argc > 1) 157 samples = strtoull(argv[1], NULL, 0); 158 else 159 samples = calibrate(); 160 161 printf("Benchmarking %llu syscalls...\n", samples); 162 163 /* Native call */ 164 native = timing(CLOCK_PROCESS_CPUTIME_ID, samples) / samples; 165 printf("getpid native: %llu ns\n", native); 166 167 ret = prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0); 168 assert(ret == 0); 169 170 /* One filter resulting in a bitmap */ 171 ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &bitmap_prog); 172 assert(ret == 0); 173 174 bitmap1 = timing(CLOCK_PROCESS_CPUTIME_ID, samples) / samples; 175 printf("getpid RET_ALLOW 1 filter (bitmap): %llu ns\n", bitmap1); 176 177 /* Second filter resulting in a bitmap */ 178 ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &bitmap_prog); 179 assert(ret == 0); 180 181 bitmap2 = timing(CLOCK_PROCESS_CPUTIME_ID, samples) / samples; 182 printf("getpid RET_ALLOW 2 filters (bitmap): %llu ns\n", bitmap2); 183 184 /* Third filter, can no longer be converted to bitmap */ 185 ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog); 186 assert(ret == 0); 187 188 filter1 = timing(CLOCK_PROCESS_CPUTIME_ID, samples) / samples; 189 printf("getpid RET_ALLOW 3 filters (full): %llu ns\n", filter1); 190 191 /* Fourth filter, can not be converted to bitmap because of filter 3 */ 192 ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &bitmap_prog); 193 assert(ret == 0); 194 195 filter2 = timing(CLOCK_PROCESS_CPUTIME_ID, samples) / samples; 196 printf("getpid RET_ALLOW 4 filters (full): %llu ns\n", filter2); 197 198 /* Estimations */ 199 #define ESTIMATE(fmt, var, what) do { \ 200 var = (what); \ 201 printf("Estimated " fmt ": %llu ns\n", var); \ 202 if (var > INT_MAX) \ 203 goto more_samples; \ 204 } while (0) 205 206 ESTIMATE("total seccomp overhead for 1 bitmapped filter", calc, 207 bitmap1 - native); 208 ESTIMATE("total seccomp overhead for 2 bitmapped filters", calc, 209 bitmap2 - native); 210 ESTIMATE("total seccomp overhead for 3 full filters", calc, 211 filter1 - native); 212 ESTIMATE("total seccomp overhead for 4 full filters", calc, 213 filter2 - native); 214 ESTIMATE("seccomp entry overhead", entry, 215 bitmap1 - native - (bitmap2 - bitmap1)); 216 ESTIMATE("seccomp per-filter overhead (last 2 diff)", per_filter1, 217 filter2 - filter1); 218 ESTIMATE("seccomp per-filter overhead (filters / 4)", per_filter2, 219 (filter2 - native - entry) / 4); 220 221 printf("Expectations:\n"); 222 ret |= compare("native", "≤", "1 bitmap", native, le, bitmap1); 223 bits = compare("native", "≤", "1 filter", native, le, filter1); 224 if (bits) 225 goto more_samples; 226 227 ret |= compare("per-filter (last 2 diff)", "≈", "per-filter (filters / 4)", 228 per_filter1, approx, per_filter2); 229 230 bits = compare("1 bitmapped", "≈", "2 bitmapped", 231 bitmap1 - native, approx, bitmap2 - native); 232 if (bits) { 233 printf("Skipping constant action bitmap expectations: they appear unsupported.\n"); 234 goto out; 235 } 236 237 ret |= compare("entry", "≈", "1 bitmapped", entry, approx, bitmap1 - native); 238 ret |= compare("entry", "≈", "2 bitmapped", entry, approx, bitmap2 - native); 239 ret |= compare("native + entry + (per filter * 4)", "≈", "4 filters total", 240 entry + (per_filter1 * 4) + native, approx, filter2); 241 if (ret == 0) 242 goto out; 243 244 more_samples: 245 printf("Saw unexpected benchmark result. Try running again with more samples?\n"); 246 out: 247 return 0; 248 } 249