Struct TypeDatabase

pub struct TypeDatabase { /* private fields */ }

Holds type information.

Implementations

impl TypeDatabase

pub fn add_btf_types(&mut self, btf: &Btf) -> Result<()>

Adds a parsed list of BTF types to this type database.

Arguments

• name - The optional name of the type.
• btf - The BTF types.

Example

use bpf_script::types::TypeDatabase;
use btf::Btf;

let btf = Btf::from_file("/sys/kernel/btf/vmlinux").expect("Failed to parse vmlinux btf");
let mut database = TypeDatabase::default();

database
    .add_btf_types(&btf)
    .expect("failed to add btf types");
database
    .get_type_by_name("task_struct")
    .expect("Couldn't find task_struct");

impl TypeDatabase

pub fn add_type(&mut self, name: Option<&str>, ty: &Type) -> Result<usize>

Adds a type to the type database.

Arguments

• name - The name of the type.
• ty - The type to add.

pub fn get_type_by_name(&self, name: &str) -> Option<&Type>

Finds a type in the database by name.

Arguments

• name - The name of the type.

pub fn get_type_by_id(&self, id: usize) -> Option<&Type>

Finds a type in the database by id.

Arguments

• id - The id of the type.

pub fn get_type_id_by_name(&self, name: &str) -> Option<usize>

Gets a type’s id by its name.

Arguments

• name - The name of the type.

pub fn add_integer( &mut self, name: Option<&str>, bytes: u32, is_signed: bool, ) -> Result<usize>

Convenience function for adding an integer type to the database.

Arguments

• name - The name of the type.
• bytes - The number of bits
• is_signed - If the integer is signed.

Examples found in repository

examples/print-instructions.rs (line 16)

fn main() {
    let prog = r#"
            fn(vec: &iovec)
              vec_copy: iovec = 0
              vec_copy.iov_base = vec.iov_base
              vec_copy.iov_len = vec.iov_len
              return 50
        "#;

    let mut database = TypeDatabase::default();

    let u64id = database
        .add_integer(Some("__u64"), 8, false)
        .expect("Failed to add type.");

    let iov_base = Field {
        offset: 0,
        type_id: u64id,
    };

    let iov_len = Field {
        offset: 64,
        type_id: u64id,
    };

    database
        .add_struct(
            Some("iovec"),
            &[("iov_base", iov_base), ("iov_len", iov_len)],
        )
        .expect("Failed to add type.");
    let mut compiler = Compiler::create(&database);
    compiler.compile(prog).unwrap();

    for ins in compiler.get_instructions() {
        println!("{}", ins);
    }
}

pub fn add_float(&mut self, name: Option<&str>, bits: u32) -> Result<usize>

Convenience function for adding a float type to the database.

Arguments

• name - The name of the type.
• bits - The number of bits.

pub fn add_array( &mut self, name: Option<&str>, element_type_id: usize, num_elements: u32, ) -> Result<usize>

Convenience function for adding an array to the database.

Arguments

• name - The name of the type.
• element_type_id - The type id of the element.
• num_elements - The number of elements in the array.

pub fn add_struct( &mut self, name: Option<&str>, fields: &[(&str, Field)], ) -> Result<usize>

Convenience function for adding a struct to the database.

Arguments

• name - The name of the type.
• fields - The fields to add.

Examples found in repository

examples/print-instructions.rs (lines 30-33)

fn main() {
    let prog = r#"
            fn(vec: &iovec)
              vec_copy: iovec = 0
              vec_copy.iov_base = vec.iov_base
              vec_copy.iov_len = vec.iov_len
              return 50
        "#;

    let mut database = TypeDatabase::default();

    let u64id = database
        .add_integer(Some("__u64"), 8, false)
        .expect("Failed to add type.");

    let iov_base = Field {
        offset: 0,
        type_id: u64id,
    };

    let iov_len = Field {
        offset: 64,
        type_id: u64id,
    };

    database
        .add_struct(
            Some("iovec"),
            &[("iov_base", iov_base), ("iov_len", iov_len)],
        )
        .expect("Failed to add type.");
    let mut compiler = Compiler::create(&database);
    compiler.compile(prog).unwrap();

    for ins in compiler.get_instructions() {
        println!("{}", ins);
    }
}

pub fn add_struct_by_ids( &mut self, name: Option<&str>, fields: &[(&str, usize)], ) -> Result<usize>

Convenience function for adding a struct to the database using a slice of (field_name, type_id). Types are added in order, and packed together contiguously.

Arguments

• name - The name of the type.
• fields - The fields to add (by id).

pub fn add_struct_by_names( &mut self, name: Option<&str>, fields: &[(&str, &str)], ) -> Result<usize>

Convenience function for adding a struct to the database using a slice of (field_name, type_name). Types are added in order, and packed together contiguously.

Arguments

• name - The name of the type.
• fields - The fields to add (by name).

Trait Implementations

impl Clone for TypeDatabase

fn clone(&self) -> TypeDatabase

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TypeDatabase

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TypeDatabase

fn default() -> TypeDatabase

Returns the “default value” for a type.