include/linux/filter.h

   1 /*
   2  * Linux Socket Filter Data Structures
   3  */
   4 #ifndef __LINUX_FILTER_H__
   5 #define __LINUX_FILTER_H__
   6
   7 #include <linux/atomic.h>
   8 #include <linux/compat.h>
   9 #include <linux/workqueue.h>
  10 #include <uapi/linux/filter.h>
  11
  12 /* Internally used and optimized filter representation with extended
  13  * instruction set based on top of classic BPF.
  14  */
  15
  16 /* instruction classes */
  17 #define BPF_ALU64       0x07    /* alu mode in double word width */
  18
  19 /* ld/ldx fields */
  20 #define BPF_DW          0x18    /* double word */
  21 #define BPF_XADD        0xc0    /* exclusive add */
  22
  23 /* alu/jmp fields */
  24 #define BPF_MOV         0xb0    /* mov reg to reg */
  25 #define BPF_ARSH        0xc0    /* sign extending arithmetic shift right */
  26
  27 /* change endianness of a register */
  28 #define BPF_END         0xd0    /* flags for endianness conversion: */
  29 #define BPF_TO_LE       0x00    /* convert to little-endian */
  30 #define BPF_TO_BE       0x08    /* convert to big-endian */
  31 #define BPF_FROM_LE     BPF_TO_LE
  32 #define BPF_FROM_BE     BPF_TO_BE
  33
  34 #define BPF_JNE         0x50    /* jump != */
  35 #define BPF_JSGT        0x60    /* SGT is signed '>', GT in x86 */
  36 #define BPF_JSGE        0x70    /* SGE is signed '>=', GE in x86 */
  37 #define BPF_CALL        0x80    /* function call */
  38 #define BPF_EXIT        0x90    /* function return */
  39
  40 /* Placeholder/dummy for 0 */
  41 #define BPF_0           0
  42
  43 /* Register numbers */
  44 enum {
  45         BPF_REG_0 = 0,
  46         BPF_REG_1,
  47         BPF_REG_2,
  48         BPF_REG_3,
  49         BPF_REG_4,
  50         BPF_REG_5,
  51         BPF_REG_6,
  52         BPF_REG_7,
  53         BPF_REG_8,
  54         BPF_REG_9,
  55         BPF_REG_10,
  56         __MAX_BPF_REG,
  57 };
  58
  59 /* BPF has 10 general purpose 64-bit registers and stack frame. */
  60 #define MAX_BPF_REG     __MAX_BPF_REG
  61
  62 /* ArgX, context and stack frame pointer register positions. Note,
  63  * Arg1, Arg2, Arg3, etc are used as argument mappings of function
  64  * calls in BPF_CALL instruction.
  65  */
  66 #define BPF_REG_ARG1    BPF_REG_1
  67 #define BPF_REG_ARG2    BPF_REG_2
  68 #define BPF_REG_ARG3    BPF_REG_3
  69 #define BPF_REG_ARG4    BPF_REG_4
  70 #define BPF_REG_ARG5    BPF_REG_5
  71 #define BPF_REG_CTX     BPF_REG_6
  72 #define BPF_REG_FP      BPF_REG_10
  73
  74 /* Additional register mappings for converted user programs. */
  75 #define BPF_REG_A       BPF_REG_0
  76 #define BPF_REG_X       BPF_REG_7
  77 #define BPF_REG_TMP     BPF_REG_8
  78
  79 /* BPF program can access up to 512 bytes of stack space. */
  80 #define MAX_BPF_STACK   512
  81
  82 /* Macro to invoke filter function. */
  83 #define SK_RUN_FILTER(filter, ctx)  (*filter->bpf_func)(ctx, filter->insnsi)
  84
  85 struct sock_filter_int {
  86         __u8    code;           /* opcode */
  87         __u8    a_reg:4;        /* dest register */
  88         __u8    x_reg:4;        /* source register */
  89         __s16   off;            /* signed offset */
  90         __s32   imm;            /* signed immediate constant */
  91 };
  92
  93 #ifdef CONFIG_COMPAT
  94 /* A struct sock_filter is architecture independent. */
  95 struct compat_sock_fprog {
  96         u16             len;
  97         compat_uptr_t   filter; /* struct sock_filter * */
  98 };
  99 #endif
 100
 101 struct sock_fprog_kern {
 102         u16                     len;
 103         struct sock_filter      *filter;
 104 };
 105
 106 struct sk_buff;
 107 struct sock;
 108 struct seccomp_data;
 109
 110 struct sk_filter {
 111         atomic_t                refcnt;
 112         u32                     jited:1,        /* Is our filter JIT'ed? */
 113                                 len:31;         /* Number of filter blocks */
 114         struct sock_fprog_kern  *orig_prog;     /* Original BPF program */
 115         struct rcu_head         rcu;
 116         unsigned int            (*bpf_func)(const struct sk_buff *skb,
 117                                             const struct sock_filter_int *filter);
 118         union {
 119                 struct sock_filter      insns[0];
 120                 struct sock_filter_int  insnsi[0];
 121                 struct work_struct      work;
 122         };
 123 };
 124
 125 static inline unsigned int sk_filter_size(unsigned int proglen)
 126 {
 127         return max(sizeof(struct sk_filter),
 128                    offsetof(struct sk_filter, insns[proglen]));
 129 }
 130
 131 #define sk_filter_proglen(fprog)                        \
 132                 (fprog->len * sizeof(fprog->filter[0]))
 133
 134 int sk_filter(struct sock *sk, struct sk_buff *skb);
 135
 136 u32 sk_run_filter_int_seccomp(const struct seccomp_data *ctx,
 137                               const struct sock_filter_int *insni);
 138 u32 sk_run_filter_int_skb(const struct sk_buff *ctx,
 139                           const struct sock_filter_int *insni);
 140
 141 int sk_convert_filter(struct sock_filter *prog, int len,
 142                       struct sock_filter_int *new_prog, int *new_len);
 143
 144 int sk_unattached_filter_create(struct sk_filter **pfp,
 145                                 struct sock_fprog *fprog);
 146 void sk_unattached_filter_destroy(struct sk_filter *fp);
 147
 148 int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk);
 149 int sk_detach_filter(struct sock *sk);
 150
 151 int sk_chk_filter(struct sock_filter *filter, unsigned int flen);
 152 int sk_get_filter(struct sock *sk, struct sock_filter __user *filter,
 153                   unsigned int len);
 154 void sk_decode_filter(struct sock_filter *filt, struct sock_filter *to);
 155
 156 void sk_filter_charge(struct sock *sk, struct sk_filter *fp);
 157 void sk_filter_uncharge(struct sock *sk, struct sk_filter *fp);
 158
 159 #ifdef CONFIG_BPF_JIT
 160 #include <stdarg.h>
 161 #include <linux/linkage.h>
 162 #include <linux/printk.h>
 163
 164 void bpf_jit_compile(struct sk_filter *fp);
 165 void bpf_jit_free(struct sk_filter *fp);
 166
 167 static inline void bpf_jit_dump(unsigned int flen, unsigned int proglen,
 168                                 u32 pass, void *image)
 169 {
 170         pr_err("flen=%u proglen=%u pass=%u image=%pK\n",
 171                flen, proglen, pass, image);
 172         if (image)
 173                 print_hex_dump(KERN_ERR, "JIT code: ", DUMP_PREFIX_OFFSET,
 174                                16, 1, image, proglen, false);
 175 }
 176 #else
 177 #include <linux/slab.h>
 178 static inline void bpf_jit_compile(struct sk_filter *fp)
 179 {
 180 }
 181 static inline void bpf_jit_free(struct sk_filter *fp)
 182 {
 183         kfree(fp);
 184 }
 185 #endif
 186
 187 static inline int bpf_tell_extensions(void)
 188 {
 189         return SKF_AD_MAX;
 190 }
 191
 192 enum {
 193         BPF_S_RET_K = 1,
 194         BPF_S_RET_A,
 195         BPF_S_ALU_ADD_K,
 196         BPF_S_ALU_ADD_X,
 197         BPF_S_ALU_SUB_K,
 198         BPF_S_ALU_SUB_X,
 199         BPF_S_ALU_MUL_K,
 200         BPF_S_ALU_MUL_X,
 201         BPF_S_ALU_DIV_X,
 202         BPF_S_ALU_MOD_K,
 203         BPF_S_ALU_MOD_X,
 204         BPF_S_ALU_AND_K,
 205         BPF_S_ALU_AND_X,
 206         BPF_S_ALU_OR_K,
 207         BPF_S_ALU_OR_X,
 208         BPF_S_ALU_XOR_K,
 209         BPF_S_ALU_XOR_X,
 210         BPF_S_ALU_LSH_K,
 211         BPF_S_ALU_LSH_X,
 212         BPF_S_ALU_RSH_K,
 213         BPF_S_ALU_RSH_X,
 214         BPF_S_ALU_NEG,
 215         BPF_S_LD_W_ABS,
 216         BPF_S_LD_H_ABS,
 217         BPF_S_LD_B_ABS,
 218         BPF_S_LD_W_LEN,
 219         BPF_S_LD_W_IND,
 220         BPF_S_LD_H_IND,
 221         BPF_S_LD_B_IND,
 222         BPF_S_LD_IMM,
 223         BPF_S_LDX_W_LEN,
 224         BPF_S_LDX_B_MSH,
 225         BPF_S_LDX_IMM,
 226         BPF_S_MISC_TAX,
 227         BPF_S_MISC_TXA,
 228         BPF_S_ALU_DIV_K,
 229         BPF_S_LD_MEM,
 230         BPF_S_LDX_MEM,
 231         BPF_S_ST,
 232         BPF_S_STX,
 233         BPF_S_JMP_JA,
 234         BPF_S_JMP_JEQ_K,
 235         BPF_S_JMP_JEQ_X,
 236         BPF_S_JMP_JGE_K,
 237         BPF_S_JMP_JGE_X,
 238         BPF_S_JMP_JGT_K,
 239         BPF_S_JMP_JGT_X,
 240         BPF_S_JMP_JSET_K,
 241         BPF_S_JMP_JSET_X,
 242         /* Ancillary data */
 243         BPF_S_ANC_PROTOCOL,
 244         BPF_S_ANC_PKTTYPE,
 245         BPF_S_ANC_IFINDEX,
 246         BPF_S_ANC_NLATTR,
 247         BPF_S_ANC_NLATTR_NEST,
 248         BPF_S_ANC_MARK,
 249         BPF_S_ANC_QUEUE,
 250         BPF_S_ANC_HATYPE,
 251         BPF_S_ANC_RXHASH,
 252         BPF_S_ANC_CPU,
 253         BPF_S_ANC_ALU_XOR_X,
 254         BPF_S_ANC_VLAN_TAG,
 255         BPF_S_ANC_VLAN_TAG_PRESENT,
 256         BPF_S_ANC_PAY_OFFSET,
 257         BPF_S_ANC_RANDOM,
 258 };
 259
 260 #endif /* __LINUX_FILTER_H__ */