LCOV - code coverage report
Current view: top level - include/linux - filter.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1 1 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       1             : /*
       2             :  * Linux Socket Filter Data Structures
       3             :  */
       4             : 
       5             : #ifndef __LINUX_FILTER_H__
       6             : #define __LINUX_FILTER_H__
       7             : 
       8             : #include <linux/compiler.h>
       9             : #include <linux/types.h>
      10             : 
      11             : #ifdef __KERNEL__
      12             : #include <asm/atomic.h>
      13             : #endif
      14             : 
      15             : /*
      16             :  * Current version of the filter code architecture.
      17             :  */
      18             : #define BPF_MAJOR_VERSION 1
      19             : #define BPF_MINOR_VERSION 1
      20             : 
      21             : /*
      22             :  *      Try and keep these values and structures similar to BSD, especially
      23             :  *      the BPF code definitions which need to match so you can share filters
      24             :  */
      25             :  
      26             : struct sock_filter {    /* Filter block */
      27             :         __u16   code;   /* Actual filter code */
      28             :         __u8    jt;     /* Jump true */
      29             :         __u8    jf;     /* Jump false */
      30             :         __u32   k;      /* Generic multiuse field */
      31             : };
      32             : 
      33             : struct sock_fprog {     /* Required for SO_ATTACH_FILTER. */
      34             :         unsigned short          len;    /* Number of filter blocks */
      35             :         struct sock_filter __user *filter;
      36             : };
      37           1 : 
      38             : /*
      39             :  * Instruction classes
      40             :  */
      41             : 
      42             : #define BPF_CLASS(code) ((code) & 0x07)
      43             : #define         BPF_LD          0x00
      44             : #define         BPF_LDX         0x01
      45             : #define         BPF_ST          0x02
      46             : #define         BPF_STX         0x03
      47             : #define         BPF_ALU         0x04
      48             : #define         BPF_JMP         0x05
      49             : #define         BPF_RET         0x06
      50             : #define         BPF_MISC        0x07
      51             : 
      52             : /* ld/ldx fields */
      53             : #define BPF_SIZE(code)  ((code) & 0x18)
      54             : #define         BPF_W           0x00
      55             : #define         BPF_H           0x08
      56             : #define         BPF_B           0x10
      57             : #define BPF_MODE(code)  ((code) & 0xe0)
      58             : #define         BPF_IMM         0x00
      59             : #define         BPF_ABS         0x20
      60             : #define         BPF_IND         0x40
      61             : #define         BPF_MEM         0x60
      62             : #define         BPF_LEN         0x80
      63             : #define         BPF_MSH         0xa0
      64             : 
      65             : /* alu/jmp fields */
      66             : #define BPF_OP(code)    ((code) & 0xf0)
      67             : #define         BPF_ADD         0x00
      68             : #define         BPF_SUB         0x10
      69             : #define         BPF_MUL         0x20
      70             : #define         BPF_DIV         0x30
      71             : #define         BPF_OR          0x40
      72             : #define         BPF_AND         0x50
      73             : #define         BPF_LSH         0x60
      74             : #define         BPF_RSH         0x70
      75             : #define         BPF_NEG         0x80
      76             : #define         BPF_JA          0x00
      77             : #define         BPF_JEQ         0x10
      78             : #define         BPF_JGT         0x20
      79             : #define         BPF_JGE         0x30
      80             : #define         BPF_JSET        0x40
      81             : #define BPF_SRC(code)   ((code) & 0x08)
      82             : #define         BPF_K           0x00
      83             : #define         BPF_X           0x08
      84             : 
      85             : /* ret - BPF_K and BPF_X also apply */
      86             : #define BPF_RVAL(code)  ((code) & 0x18)
      87             : #define         BPF_A           0x10
      88             : 
      89             : /* misc */
      90             : #define BPF_MISCOP(code) ((code) & 0xf8)
      91             : #define         BPF_TAX         0x00
      92             : #define         BPF_TXA         0x80
      93             : 
      94             : #ifndef BPF_MAXINSNS
      95             : #define BPF_MAXINSNS 4096
      96             : #endif
      97             : 
      98             : /*
      99             :  * Macros for filter block array initializers.
     100             :  */
     101             : #ifndef BPF_STMT
     102             : #define BPF_STMT(code, k) { (unsigned short)(code), 0, 0, k }
     103             : #endif
     104             : #ifndef BPF_JUMP
     105             : #define BPF_JUMP(code, k, jt, jf) { (unsigned short)(code), jt, jf, k }
     106             : #endif
     107             : 
     108             : /*
     109             :  * Number of scratch memory words for: BPF_ST and BPF_STX
     110             :  */
     111             : #define BPF_MEMWORDS 16
     112             : 
     113             : /* RATIONALE. Negative offsets are invalid in BPF.
     114             :    We use them to reference ancillary data.
     115             :    Unlike introduction new instructions, it does not break
     116             :    existing compilers/optimizers.
     117             :  */
     118             : #define SKF_AD_OFF    (-0x1000)
     119             : #define SKF_AD_PROTOCOL 0
     120             : #define SKF_AD_PKTTYPE  4
     121             : #define SKF_AD_IFINDEX  8
     122             : #define SKF_AD_NLATTR   12
     123             : #define SKF_AD_NLATTR_NEST      16
     124             : #define SKF_AD_MARK     20
     125             : #define SKF_AD_QUEUE    24
     126             : #define SKF_AD_MAX      28
     127             : #define SKF_NET_OFF   (-0x100000)
     128             : #define SKF_LL_OFF    (-0x200000)
     129             : 
     130             : #ifdef __KERNEL__
     131             : struct sk_filter
     132             : {
     133             :         atomic_t                refcnt;
     134             :         unsigned int            len;    /* Number of filter blocks */
     135             :         struct rcu_head         rcu;
     136             :         struct sock_filter      insns[0];
     137             : };
     138             : 
     139             : static inline unsigned int sk_filter_len(const struct sk_filter *fp)
     140             : {
     141             :         return fp->len * sizeof(struct sock_filter) + sizeof(*fp);
     142             : }
     143             : 
     144             : struct sk_buff;
     145             : struct sock;
     146             : 
     147             : extern int sk_filter(struct sock *sk, struct sk_buff *skb);
     148             : extern unsigned int sk_run_filter(struct sk_buff *skb,
     149             :                                   struct sock_filter *filter, int flen);
     150             : extern int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk);
     151             : extern int sk_detach_filter(struct sock *sk);
     152             : extern int sk_chk_filter(struct sock_filter *filter, int flen);
     153             : #endif /* __KERNEL__ */
     154             : 
     155             : #endif /* __LINUX_FILTER_H__ */

Generated by: LCOV version 1.10