Up  

Module EBPF

module EBPF: sig .. end
Embedded eBPF assembler

Types


type size =
| W (*
word = 32 bit
*)
| H (*
half-word = 16 bit
*)
| B (*
byte
*)
| DW (*
double word = 64 bit
*) 
type reg =
| R0
| R1
| R2
| R3
| R4
| R5
| R6
| R7
| R8
| R9
| R10 
type int16 = int 
type cond = [ `EQ | `GE | `GT | `NE | `SET | `SGE | `SGT ] 
type +'label insn
Single eBPF instruction. 'label is type of labels, can be any hashable type, e.g. string, int, open variant, etc

Memory instructions


val ldx : size -> reg -> reg * int16 -> 'a insn
val lddw : reg -> int64 -> 'a insn
val stx : size -> reg * int16 -> reg -> 'a insn
val st : size -> reg * int16 -> int -> 'a insn

Branch instructions


val label : 'label -> 'label insn
mark label position, each label should be unique
val ret : 'a insn
val call : int -> 'a insn
val jump : 'label -> 'label insn
val jmpi : 'label -> reg -> cond -> int -> 'label insn
val jmp : 'label -> reg -> cond -> reg -> 'label insn

raw jump instructions with manually-computed offset

you probably want to use functions above which take labels

val jump_ : int16 -> 'a insn
val jmpi_ : int16 -> reg -> cond -> int -> 'a insn
val jmp_ : int16 -> reg -> cond -> reg -> 'a insn

ALU (arithmetic/logic) instructions


module type ALU = sig .. end
module I32: ALU 
include EBPF.ALU
64-bit instructions, for 32-bit instructions use I32

Byteswap instructions


val le16 : reg -> 'a insn
val be16 : reg -> 'a insn
val le32 : reg -> 'a insn
val be32 : reg -> 'a insn
val le64 : reg -> 'a insn
val be64 : reg -> 'a insn

Assembler


type options = {
   disable_all_checks : bool; (*
disable all checks, may generate invalid code
*)
   jump_back : bool; (*
allow jump backwards, may result in infinite loop
*)
   jump_self : bool; (*
allow jump to self, guaranteed infinite loop
*)
} 
val default : options
val assemble : ?options:options -> 'a insn list -> string