github.com/datadog/cilium@v1.6.12/bpf/probes/raw_insn.h (about)

     1  #ifndef RAW_INSN_H
     2  #define RAW_INSN_H
     3  
     4  #include <linux/bpf.h>
     5  
     6  #define BPF_ALU64_REG(OP, DST, SRC)				\
     7  	((struct bpf_insn) {					\
     8  		.code  = BPF_ALU64 | BPF_OP(OP) | BPF_X,	\
     9  		.dst_reg = DST,					\
    10  		.src_reg = SRC,					\
    11  		.off   = 0,					\
    12  		.imm   = 0 })
    13  
    14  #define BPF_ALU32_REG(OP, DST, SRC)				\
    15  	((struct bpf_insn) {					\
    16  		.code  = BPF_ALU | BPF_OP(OP) | BPF_X,		\
    17  		.dst_reg = DST,					\
    18  		.src_reg = SRC,					\
    19  		.off   = 0,					\
    20  		.imm   = 0 })
    21  
    22  #define BPF_ALU64_IMM(OP, DST, IMM)				\
    23  	((struct bpf_insn) {					\
    24  		.code  = BPF_ALU64 | BPF_OP(OP) | BPF_K,	\
    25  		.dst_reg = DST,					\
    26  		.src_reg = 0,					\
    27  		.off   = 0,					\
    28  		.imm   = IMM })
    29  
    30  #define BPF_ALU32_IMM(OP, DST, IMM)				\
    31  	((struct bpf_insn) {					\
    32  		.code  = BPF_ALU | BPF_OP(OP) | BPF_K,		\
    33  		.dst_reg = DST,					\
    34  		.src_reg = 0,					\
    35  		.off   = 0,					\
    36  		.imm   = IMM })
    37  
    38  #define BPF_ENDIAN(TYPE, DST, LEN)				\
    39  	((struct bpf_insn) {					\
    40  		.code  = BPF_ALU | BPF_END | BPF_SRC(TYPE),	\
    41  		.dst_reg = DST,					\
    42  		.src_reg = 0,					\
    43  		.off   = 0,					\
    44  		.imm   = LEN })
    45  
    46  #define BPF_MOV64_REG(DST, SRC)					\
    47  	((struct bpf_insn) {					\
    48  		.code  = BPF_ALU64 | BPF_MOV | BPF_X,		\
    49  		.dst_reg = DST,					\
    50  		.src_reg = SRC,					\
    51  		.off   = 0,					\
    52  		.imm   = 0 })
    53  
    54  #define BPF_MOV32_REG(DST, SRC)					\
    55  	((struct bpf_insn) {					\
    56  		.code  = BPF_ALU | BPF_MOV | BPF_X,		\
    57  		.dst_reg = DST,					\
    58  		.src_reg = SRC,					\
    59  		.off   = 0,					\
    60  		.imm   = 0 })
    61  
    62  #define BPF_MOV64_IMM(DST, IMM)					\
    63  	((struct bpf_insn) {					\
    64  		.code  = BPF_ALU64 | BPF_MOV | BPF_K,		\
    65  		.dst_reg = DST,					\
    66  		.src_reg = 0,					\
    67  		.off   = 0,					\
    68  		.imm   = IMM })
    69  
    70  #define BPF_MOV32_IMM(DST, IMM)					\
    71  	((struct bpf_insn) {					\
    72  		.code  = BPF_ALU | BPF_MOV | BPF_K,		\
    73  		.dst_reg = DST,					\
    74  		.src_reg = 0,					\
    75  		.off   = 0,					\
    76  		.imm   = IMM })
    77  
    78  #define BPF_LD_IMM64(DST, IMM)					\
    79  	BPF_LD_IMM64_RAW(DST, 0, IMM)
    80  
    81  #define BPF_LD_IMM64_RAW(DST, SRC, IMM)				\
    82  	((struct bpf_insn) {					\
    83  		.code  = BPF_LD | BPF_DW | BPF_IMM,		\
    84  		.dst_reg = DST,					\
    85  		.src_reg = SRC,					\
    86  		.off   = 0,					\
    87  		.imm   = (__u32) (IMM) }),			\
    88  	((struct bpf_insn) {					\
    89  		.code  = 0,					\
    90  		.dst_reg = 0,					\
    91  		.src_reg = 0,					\
    92  		.off   = 0,					\
    93  		.imm   = ((__u64) (IMM)) >> 32 })
    94  
    95  #define BPF_LD_MAP_FD(DST, MAP_FD)				\
    96  	BPF_LD_IMM64_RAW(DST, BPF_PSEUDO_MAP_FD, MAP_FD)
    97  
    98  #define BPF_MOV64_RAW(TYPE, DST, SRC, IMM)			\
    99  	((struct bpf_insn) {					\
   100  		.code  = BPF_ALU64 | BPF_MOV | BPF_SRC(TYPE),	\
   101  		.dst_reg = DST,					\
   102  		.src_reg = SRC,					\
   103  		.off   = 0,					\
   104  		.imm   = IMM })
   105  
   106  #define BPF_MOV32_RAW(TYPE, DST, SRC, IMM)			\
   107  	((struct bpf_insn) {					\
   108  		.code  = BPF_ALU | BPF_MOV | BPF_SRC(TYPE),	\
   109  		.dst_reg = DST,					\
   110  		.src_reg = SRC,					\
   111  		.off   = 0,					\
   112  		.imm   = IMM })
   113  
   114  #define BPF_LD_ABS(SIZE, IMM)					\
   115  	((struct bpf_insn) {					\
   116  		.code  = BPF_LD | BPF_SIZE(SIZE) | BPF_ABS,	\
   117  		.dst_reg = 0,					\
   118  		.src_reg = 0,					\
   119  		.off   = 0,					\
   120  		.imm   = IMM })
   121  
   122  #define BPF_LD_IND(SIZE, SRC, IMM)				\
   123  	((struct bpf_insn) {					\
   124  		.code  = BPF_LD | BPF_SIZE(SIZE) | BPF_IND,	\
   125  		.dst_reg = 0,					\
   126  		.src_reg = SRC,					\
   127  		.off   = 0,					\
   128  		.imm   = IMM })
   129  
   130  #define BPF_LDX_MEM(SIZE, DST, SRC, OFF)			\
   131  	((struct bpf_insn) {					\
   132  		.code  = BPF_LDX | BPF_SIZE(SIZE) | BPF_MEM,	\
   133  		.dst_reg = DST,					\
   134  		.src_reg = SRC,					\
   135  		.off   = OFF,					\
   136  		.imm   = 0 })
   137  
   138  #define BPF_STX_MEM(SIZE, DST, SRC, OFF)			\
   139  	((struct bpf_insn) {					\
   140  		.code  = BPF_STX | BPF_SIZE(SIZE) | BPF_MEM,	\
   141  		.dst_reg = DST,					\
   142  		.src_reg = SRC,					\
   143  		.off   = OFF,					\
   144  		.imm   = 0 })
   145  
   146  #define BPF_STX_XADD(SIZE, DST, SRC, OFF)			\
   147  	((struct bpf_insn) {					\
   148  		.code  = BPF_STX | BPF_SIZE(SIZE) | BPF_XADD,	\
   149  		.dst_reg = DST,					\
   150  		.src_reg = SRC,					\
   151  		.off   = OFF,					\
   152  		.imm   = 0 })
   153  
   154  #define BPF_ST_MEM(SIZE, DST, OFF, IMM)				\
   155  	((struct bpf_insn) {					\
   156  		.code  = BPF_ST | BPF_SIZE(SIZE) | BPF_MEM,	\
   157  		.dst_reg = DST,					\
   158  		.src_reg = 0,					\
   159  		.off   = OFF,					\
   160  		.imm   = IMM })
   161  
   162  #define BPF_JMP_REG(OP, DST, SRC, OFF)				\
   163  	((struct bpf_insn) {					\
   164  		.code  = BPF_JMP | BPF_OP(OP) | BPF_X,		\
   165  		.dst_reg = DST,					\
   166  		.src_reg = SRC,					\
   167  		.off   = OFF,					\
   168  		.imm   = 0 })
   169  
   170  #define BPF_JMP_IMM(OP, DST, IMM, OFF)				\
   171  	((struct bpf_insn) {					\
   172  		.code  = BPF_JMP | BPF_OP(OP) | BPF_K,		\
   173  		.dst_reg = DST,					\
   174  		.src_reg = 0,					\
   175  		.off   = OFF,					\
   176  		.imm   = IMM })
   177  
   178  #define BPF_EMIT_CALL(FUNC)					\
   179  	((struct bpf_insn) {					\
   180  		.code  = BPF_JMP | BPF_CALL,			\
   181  		.dst_reg = 0,					\
   182  		.src_reg = 0,					\
   183  		.off   = 0,					\
   184  		.imm   = ((FUNC) - BPF_FUNC_unspec) })
   185  
   186  #define BPF_RAW_INSN(CODE, DST, SRC, OFF, IMM)			\
   187  	((struct bpf_insn) {					\
   188  		.code  = CODE,					\
   189  		.dst_reg = DST,					\
   190  		.src_reg = SRC,					\
   191  		.off   = OFF,					\
   192  		.imm   = IMM })
   193  
   194  #define BPF_EXIT_INSN()						\
   195  	((struct bpf_insn) {					\
   196  		.code  = BPF_JMP | BPF_EXIT,			\
   197  		.dst_reg = 0,					\
   198  		.src_reg = 0,					\
   199  		.off   = 0,					\
   200  		.imm   = 0 })
   201  
   202  #endif /* RAW_INSN_H */