
Máquina virtual Rust e compilador JIT para programas eBPF
Máquina virtual Rust (espaço de usuário) para eBPF
Este crate contém uma máquina virtual para execução de programas eBPF. BPF, como em Berkeley Packet Filter, é uma linguagem do tipo assembly inicialmente desenvolvida para sistemas BSD, a fim de filtrar pacotes no kernel com ferramentas como tcpdump para evitar cópias inúteis para o espaço de usuário. Ela foi portada para o Linux, onde evoluiu para eBPF (extended BPF), uma versão mais rápida com mais recursos. Embora os programas BPF sejam originalmente destinados a rodar no kernel, a máquina virtual deste crate permite executá-los em aplicações de espaço de usuário; ela contém um interpretador, um compilador JIT x86_64 para programas eBPF, bem como um desmontador.
Ela é baseada no software uBPF de Rich Lane, que faz quase o mesmo, mas é escrito em C.
O crate deve compilar e rodar em Linux, MacOS X e Windows, embora o compilador JIT não funcione com Windows no momento.
Este crate está disponível em crates.io, então ele
deve funcionar imediatamente ao adicioná-lo como dependência no seu arquivo Cargo.toml:
[dependencies]
rbpf = "0.4.2"
Também podes usar a versão de desenvolvimento deste repositório GitHub. Isto
deve ser tão simples como colocar isto dentro do teu Cargo.toml:
[dependencies]
rbpf = { git = "https://github.com/qmonnet/rbpf" }
Naturalmente, se preferir, você pode cloná-lo localmente, possivelmente modificar o crate,
e então indicar o caminho da sua versão local em Cargo.toml:
[dependencies]
rbpf = { path = "path/to/rbpf" }
Em seguida, indique no seu código-fonte que deseja usar o crate:
extern crate rbpf;
A API está muito bem documentada dentro do código-fonte. Você também deve conseguir acessar uma versão online da documentação a partir daqui, gerada automaticamente a partir da versão do crates.io (pode não estar atualizada em relação ao branch principal). Exemplos e testes unitários também devem ser úteis. Segue um resumo de como usar a crate.
Aqui estão os passos a seguir para executar um programa eBPF com o rbpf:
O eBPF foi inicialmente projetado para filtrar pacotes (agora ele tem alguns outros hooks no kernel Linux, como kprobes, mas isso não é coberto pelo rbpf). Como consequência, a maioria das instruções de load e store do programa é executada em uma área de memória que representa os dados do pacote. No entanto, no kernel Linux, o programa eBPF não acessa imediatamente essa área de dados: inicialmente, ele tem acesso a uma struct sk_buff em C, que é um buffer contendo metadados sobre o pacote — incluindo os endereços de memória do início e do fim da área de dados do pacote. Assim, o programa primeiro carrega esses ponteiros a partir da sk_buff e, em seguida, pode acessar os dados do pacote.
Esse comportamento pode ser replicado com o rbpf, mas não é obrigatório. Por esse motivo, temos várias structs representando diferentes tipos de máquinas virtuais:
struct EbpfVmMbuffer imita o kernel. Quando o programa é executado, o endereço fornecido ao seu primeiro registrador eBPF será o endereço de um buffer de metadados fornecido pelo usuário, e espera-se que ele contenha ponteiros para o início e o fim da área de memória dos dados do pacote.
struct EbpfVmFixedMbuff tem um único propósito: permitir a execução de programas criados para serem compatíveis com o kernel, poupando o usuário do esforço de lidar manualmente com o buffer de metadados. Na verdade, essa struct possui um buffer interno estático que é passado ao programa. O usuário deve indicar os valores de offset nos quais o programa eBPF espera encontrar o início e o fim dos dados do pacote no buffer. Ao chamar a função que executa o programa (com JIT ou não), a struct atualiza automaticamente os endereços nesse buffer estático, nos offsets designados, para o início e o fim dos dados do pacote sobre os quais o programa é chamado.
struct EbpfVmRaw é para programas que desejam ser executados diretamente sobre os dados do pacote. Nenhum buffer de metadados está envolvido; o programa eBPF recebe diretamente o endereço dos dados do pacote em seu primeiro registrador. Esse é o comportamento do uBPF.
struct EbpfVmNoData não recebe nenhum dado. O programa eBPF não recebe argumento algum e seu valor de retorno é determinístico. Não tenho tanta certeza de que haja um caso de uso válido para isso, mas, no mínimo, isso é muito útil para testes unitários.
Todas essas structs implementam as mesmas funções públicas:
// called with EbpfVmMbuff:: prefix
pub fn new(prog: &'a [u8]) -> Result<EbpfVmMbuff<'a>, Error>
// called with EbpfVmFixedMbuff:: prefix
pub fn new(prog: &'a [u8],
data_offset: usize,
data_end_offset: usize) -> Result<EbpfVmFixedMbuff<'a>, Error>
// called with EbpfVmRaw:: prefix
pub fn new(prog: &'a [u8]) -> Result<EbpfVmRaw<'a>, Error>
// called with EbpfVmNoData:: prefix
pub fn new(prog: &'a [u8]) -> Result<EbpfVmNoData<'a>, Error>
Isto é usado para criar uma nova instância de uma VM. O tipo de retorno depende da struct a partir da qual a função é chamada. Por exemplo, rbpf::EbpfVmRaw::new(Some(my_program)) retornaria uma instância de struct rbpf::EbpfVmRaw (envolvida em um Result). Quando um programa é carregado, ele é verificado com um verificador muito simples (nada próximo ao do kernel Linux). Os usuários também podem substituí-lo por um verificador personalizado.
Para struct EbpfVmFixedMbuff, dois argumentos adicionais devem ser passados ao construtor: data_offset e data_end_offset. Eles são o deslocamento (número de bytes) no qual os ponteiros para o início e para o fim, respectivamente, da área de memória dos dados do pacote devem ser armazenados no buffer de metadados interno a cada execução do programa. Outras structs não usam esse mecanismo e não precisam desses deslocamentos.
// for struct EbpfVmMbuff, struct EbpfVmRaw and struct EbpfVmRawData
pub fn set_program(&mut self, prog: &'a [u8]) -> Result<(), Error>