Description

Newbie level knowledge of eBPF and some knowledge of Haskell. The goal for this hackweek is to catch two birds with one stone; get familiar with eBPF and learn more about Haskell, hence implement something related to eBPF in Haskell. Given an input, which is a program, represented as eBPF instructions, prepare a fully built eBPF bytecode ready to be loaded into the Kernel.

Goals

• Recap on ADTs in Haskell, type classes and their instances / deriving, on pattern matching and higher order functions
• Read and understand RFC 9669
• Implement the entire pipeline; parsing the input, verifying the input, building instructions, encoding them and concatenating them
• Deal with all the learning, bugs and difficulties encountered on the way

Progress

Last day of hackweek and this is what I have so far.

• ADTs implemented to correctly type all operations, classes, opcodes, instructions and other instruction specific types
• opcodes and opcode builders based on specification are implemented.
• Encoder is ready for 64-bit instruction format. Extended 128-bit instruction format is not yet supported
• Only ALU and ALU64 instructions API is provided. JMP, LD, ST for base32 and base64 are missing. swap and atomic are missing
• All ALU and ALU64 instructions (except MOV and MOVSX) are tested manually and are correctly encoded

Whats next?

There is still a lot left to do:

• Input parser and formatter + some kind of basic verifier
• API for remaining instruction classes
• Proper testing mechanism
• swap and atomic instructions
• Loader

Resources

• RFC 9669
• https://ebpf.io/
• https://www.haskell.org/documentation/