tools/testing/selftests/seccomp/seccomp_benchmark.c

   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         ksft_print_msg("%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         ksft_print_msg("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         ksft_print_msg("\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                 ksft_print_msg("Miscalculation! Measurement went negative: %lld\n", (long long)one);
 109                 return 1;
 110         }
 111         if (two > INT_MAX) {
 112                 ksft_print_msg("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         ksft_print_msg("Running on:\n");
 149         ksft_print_msg("");
 150         system("uname -a");
 151
 152         ksft_print_msg("Current BPF sysctl settings:\n");
 153         /* Avoid using "sysctl" which may not be installed. */
 154         ksft_print_msg("");
 155         system("grep -H . /proc/sys/net/core/bpf_jit_enable");
 156         ksft_print_msg("");
 157         system("grep -H . /proc/sys/net/core/bpf_jit_harden");
 158
 159         if (argc > 1)
 160                 samples = strtoull(argv[1], NULL, 0);
 161         else
 162                 samples = calibrate();
 163
 164         ksft_print_msg("Benchmarking %llu syscalls...\n", samples);
 165
 166         /* Native call */
 167         native = timing(CLOCK_PROCESS_CPUTIME_ID, samples) / samples;
 168         ksft_print_msg("getpid native: %llu ns\n", native);
 169
 170         ret = prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
 171         assert(ret == 0);
 172
 173         /* One filter resulting in a bitmap */
 174         ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &bitmap_prog);
 175         assert(ret == 0);
 176
 177         bitmap1 = timing(CLOCK_PROCESS_CPUTIME_ID, samples) / samples;
 178         ksft_print_msg("getpid RET_ALLOW 1 filter (bitmap): %llu ns\n", bitmap1);
 179
 180         /* Second filter resulting in a bitmap */
 181         ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &bitmap_prog);
 182         assert(ret == 0);
 183
 184         bitmap2 = timing(CLOCK_PROCESS_CPUTIME_ID, samples) / samples;
 185         ksft_print_msg("getpid RET_ALLOW 2 filters (bitmap): %llu ns\n", bitmap2);
 186
 187         /* Third filter, can no longer be converted to bitmap */
 188         ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);
 189         assert(ret == 0);
 190
 191         filter1 = timing(CLOCK_PROCESS_CPUTIME_ID, samples) / samples;
 192         ksft_print_msg("getpid RET_ALLOW 3 filters (full): %llu ns\n", filter1);
 193
 194         /* Fourth filter, can not be converted to bitmap because of filter 3 */
 195         ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &bitmap_prog);
 196         assert(ret == 0);
 197
 198         filter2 = timing(CLOCK_PROCESS_CPUTIME_ID, samples) / samples;
 199         ksft_print_msg("getpid RET_ALLOW 4 filters (full): %llu ns\n", filter2);
 200
 201         /* Estimations */
 202 #define ESTIMATE(fmt, var, what)        do {                    \
 203                 var = (what);                                   \
 204                 ksft_print_msg("Estimated " fmt ": %llu ns\n", var);    \
 205                 if (var > INT_MAX)                              \
 206                         goto more_samples;                      \
 207         } while (0)
 208
 209         ESTIMATE("total seccomp overhead for 1 bitmapped filter", calc,
 210                  bitmap1 - native);
 211         ESTIMATE("total seccomp overhead for 2 bitmapped filters", calc,
 212                  bitmap2 - native);
 213         ESTIMATE("total seccomp overhead for 3 full filters", calc,
 214                  filter1 - native);
 215         ESTIMATE("total seccomp overhead for 4 full filters", calc,
 216                  filter2 - native);
 217         ESTIMATE("seccomp entry overhead", entry,
 218                  bitmap1 - native - (bitmap2 - bitmap1));
 219         ESTIMATE("seccomp per-filter overhead (last 2 diff)", per_filter1,
 220                  filter2 - filter1);
 221         ESTIMATE("seccomp per-filter overhead (filters / 4)", per_filter2,
 222                  (filter2 - native - entry) / 4);
 223
 224         ksft_print_msg("Expectations:\n");
 225         ret |= compare("native", "≤", "1 bitmap", native, le, bitmap1);
 226         bits = compare("native", "≤", "1 filter", native, le, filter1);
 227         if (bits)
 228                 goto more_samples;
 229
 230         ret |= compare("per-filter (last 2 diff)", "≈", "per-filter (filters / 4)",
 231                         per_filter1, approx, per_filter2);
 232
 233         bits = compare("1 bitmapped", "≈", "2 bitmapped",
 234                         bitmap1 - native, approx, bitmap2 - native);
 235         if (bits) {
 236                 ksft_print_msg("Skipping constant action bitmap expectations: they appear unsupported.\n");
 237                 goto out;
 238         }
 239
 240         ret |= compare("entry", "≈", "1 bitmapped", entry, approx, bitmap1 - native);
 241         ret |= compare("entry", "≈", "2 bitmapped", entry, approx, bitmap2 - native);
 242         ret |= compare("native + entry + (per filter * 4)", "≈", "4 filters total",
 243                         entry + (per_filter1 * 4) + native, approx, filter2);
 244         if (ret == 0)
 245                 goto out;
 246
 247 more_samples:
 248         ksft_print_msg("Saw unexpected benchmark result. Try running again with more samples?\n");
 249 out:
 250         return 0;
 251 }