LXR linux/samples/seccomp/bpf-helper.h

   1/*
   2 * Example wrapper around BPF macros.
   3 *
   4 * Copyright (c) 2012 The Chromium OS Authors <chromium-os-dev@chromium.org>
   5 * Author: Will Drewry <wad@chromium.org>
   6 *
   7 * The code may be used by anyone for any purpose,
   8 * and can serve as a starting point for developing
   9 * applications using prctl(PR_SET_SECCOMP, 2, ...).
  10 *
  11 * No guarantees are provided with respect to the correctness
  12 * or functionality of this code.
  13 */
  14#ifndef __BPF_HELPER_H__
  15#define __BPF_HELPER_H__
  16
  17#include <asm/bitsperlong.h>    /* for __BITS_PER_LONG */
  18#include <endian.h>
  19#include <linux/filter.h>
  20#include <linux/seccomp.h>      /* for seccomp_data */
  21#include <linux/types.h>
  22#include <linux/unistd.h>
  23#include <stddef.h>
  24
  25#define BPF_LABELS_MAX 256
  26struct bpf_labels {
  27        int count;
  28        struct __bpf_label {
  29                const char *label;
  30                __u32 location;
  31        } labels[BPF_LABELS_MAX];
  32};
  33
  34int bpf_resolve_jumps(struct bpf_labels *labels,
  35                      struct sock_filter *filter, size_t count);
  36__u32 seccomp_bpf_label(struct bpf_labels *labels, const char *label);
  37void seccomp_bpf_print(struct sock_filter *filter, size_t count);
  38
  39#define JUMP_JT 0xff
  40#define JUMP_JF 0xff
  41#define LABEL_JT 0xfe
  42#define LABEL_JF 0xfe
  43
  44#define ALLOW \
  45        BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_ALLOW)
  46#define DENY \
  47        BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_KILL)
  48#define JUMP(labels, label) \
  49        BPF_JUMP(BPF_JMP+BPF_JA, FIND_LABEL((labels), (label)), \
  50                 JUMP_JT, JUMP_JF)
  51#define LABEL(labels, label) \
  52        BPF_JUMP(BPF_JMP+BPF_JA, FIND_LABEL((labels), (label)), \
  53                 LABEL_JT, LABEL_JF)
  54#define SYSCALL(nr, jt) \
  55        BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (nr), 0, 1), \
  56        jt
  57
  58/* Lame, but just an example */
  59#define FIND_LABEL(labels, label) seccomp_bpf_label((labels), #label)
  60
  61#define EXPAND(...) __VA_ARGS__
  62
  63/* Ensure that we load the logically correct offset. */
  64#if __BYTE_ORDER == __LITTLE_ENDIAN
  65#define LO_ARG(idx) offsetof(struct seccomp_data, args[(idx)])
  66#elif __BYTE_ORDER == __BIG_ENDIAN
  67#define LO_ARG(idx) offsetof(struct seccomp_data, args[(idx)]) + sizeof(__u32)
  68#else
  69#error "Unknown endianness"
  70#endif
  71
  72/* Map all width-sensitive operations */
  73#if __BITS_PER_LONG == 32
  74
  75#define JEQ(x, jt) JEQ32(x, EXPAND(jt))
  76#define JNE(x, jt) JNE32(x, EXPAND(jt))
  77#define JGT(x, jt) JGT32(x, EXPAND(jt))
  78#define JLT(x, jt) JLT32(x, EXPAND(jt))
  79#define JGE(x, jt) JGE32(x, EXPAND(jt))
  80#define JLE(x, jt) JLE32(x, EXPAND(jt))
  81#define JA(x, jt) JA32(x, EXPAND(jt))
  82#define ARG(i) ARG_32(i)
  83
  84#elif __BITS_PER_LONG == 64
  85
  86/* Ensure that we load the logically correct offset. */
  87#if __BYTE_ORDER == __LITTLE_ENDIAN
  88#define ENDIAN(_lo, _hi) _lo, _hi
  89#define HI_ARG(idx) offsetof(struct seccomp_data, args[(idx)]) + sizeof(__u32)
  90#elif __BYTE_ORDER == __BIG_ENDIAN
  91#define ENDIAN(_lo, _hi) _hi, _lo
  92#define HI_ARG(idx) offsetof(struct seccomp_data, args[(idx)])
  93#endif
  94
  95union arg64 {
  96        struct {
  97                __u32 ENDIAN(lo32, hi32);
  98        };
  99        __u64 u64;
 100};
 101
 102#define JEQ(x, jt) \
 103        JEQ64(((union arg64){.u64 = (x)}).lo32, \
 104              ((union arg64){.u64 = (x)}).hi32, \
 105              EXPAND(jt))
 106#define JGT(x, jt) \
 107        JGT64(((union arg64){.u64 = (x)}).lo32, \
 108              ((union arg64){.u64 = (x)}).hi32, \
 109              EXPAND(jt))
 110#define JGE(x, jt) \
 111        JGE64(((union arg64){.u64 = (x)}).lo32, \
 112              ((union arg64){.u64 = (x)}).hi32, \
 113              EXPAND(jt))
 114#define JNE(x, jt) \
 115        JNE64(((union arg64){.u64 = (x)}).lo32, \
 116              ((union arg64){.u64 = (x)}).hi32, \
 117              EXPAND(jt))
 118#define JLT(x, jt) \
 119        JLT64(((union arg64){.u64 = (x)}).lo32, \
 120              ((union arg64){.u64 = (x)}).hi32, \
 121              EXPAND(jt))
 122#define JLE(x, jt) \
 123        JLE64(((union arg64){.u64 = (x)}).lo32, \
 124              ((union arg64){.u64 = (x)}).hi32, \
 125              EXPAND(jt))
 126
 127#define JA(x, jt) \
 128        JA64(((union arg64){.u64 = (x)}).lo32, \
 129               ((union arg64){.u64 = (x)}).hi32, \
 130               EXPAND(jt))
 131#define ARG(i) ARG_64(i)
 132
 133#else
 134#error __BITS_PER_LONG value unusable.
 135#endif
 136
 137/* Loads the arg into A */
 138#define ARG_32(idx) \
 139        BPF_STMT(BPF_LD+BPF_W+BPF_ABS, LO_ARG(idx))
 140
 141/* Loads hi into A and lo in X */
 142#define ARG_64(idx) \
 143        BPF_STMT(BPF_LD+BPF_W+BPF_ABS, LO_ARG(idx)), \
 144        BPF_STMT(BPF_ST, 0), /* lo -> M[0] */ \
 145        BPF_STMT(BPF_LD+BPF_W+BPF_ABS, HI_ARG(idx)), \
 146        BPF_STMT(BPF_ST, 1) /* hi -> M[1] */
 147
 148#define JEQ32(value, jt) \
 149        BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (value), 0, 1), \
 150        jt
 151
 152#define JNE32(value, jt) \
 153        BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (value), 1, 0), \
 154        jt
 155
 156/* Checks the lo, then swaps to check the hi. A=lo,X=hi */
 157#define JEQ64(lo, hi, jt) \
 158        BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
 159        BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
 160        BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (lo), 0, 2), \
 161        BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
 162        jt, \
 163        BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */
 164
 165#define JNE64(lo, hi, jt) \
 166        BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 5, 0), \
 167        BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
 168        BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (lo), 2, 0), \
 169        BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
 170        jt, \
 171        BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */
 172
 173#define JA32(value, jt) \
 174        BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (value), 0, 1), \
 175        jt
 176
 177#define JA64(lo, hi, jt) \
 178        BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (hi), 3, 0), \
 179        BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
 180        BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (lo), 0, 2), \
 181        BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
 182        jt, \
 183        BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */
 184
 185#define JGE32(value, jt) \
 186        BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (value), 0, 1), \
 187        jt
 188
 189#define JLT32(value, jt) \
 190        BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (value), 1, 0), \
 191        jt
 192
 193/* Shortcut checking if hi > arg.hi. */
 194#define JGE64(lo, hi, jt) \
 195        BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 4, 0), \
 196        BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
 197        BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
 198        BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (lo), 0, 2), \
 199        BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
 200        jt, \
 201        BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */
 202
 203#define JLT64(lo, hi, jt) \
 204        BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (hi), 0, 4), \
 205        BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
 206        BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
 207        BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 2, 0), \
 208        BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
 209        jt, \
 210        BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */
 211
 212#define JGT32(value, jt) \
 213        BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (value), 0, 1), \
 214        jt
 215
 216#define JLE32(value, jt) \
 217        BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (value), 1, 0), \
 218        jt
 219
 220/* Check hi > args.hi first, then do the GE checking */
 221#define JGT64(lo, hi, jt) \
 222        BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 4, 0), \
 223        BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \
 224        BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
 225        BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 0, 2), \
 226        BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
 227        jt, \
 228        BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */
 229
 230#define JLE64(lo, hi, jt) \
 231        BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 6, 0), \
 232        BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 3), \
 233        BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \
 234        BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 2, 0), \
 235        BPF_STMT(BPF_LD+BPF_MEM, 1), /* passed: swap hi back in */ \
 236        jt, \
 237        BPF_STMT(BPF_LD+BPF_MEM, 1) /* failed: swap hi back in */
 238
 239#define LOAD_SYSCALL_NR \
 240        BPF_STMT(BPF_LD+BPF_W+BPF_ABS, \
 241                 offsetof(struct seccomp_data, nr))
 242
 243#endif  /* __BPF_HELPER_H__ */
 244