Enum AuxVar 

pub enum AuxVar<'a> {
    Null,
    Ignore,
    ExecFd(usize),
    Phdr(*const u8),
    Phent(usize),
    Phnum(usize),
    Pagesz(usize),
    Base(*const u8),
    Flags(AuxVarFlags),
    Entry(*const u8),
    NotElf(bool),
    Uid(usize),
    EUid(usize),
    Gid(usize),
    EGid(usize),
    Platform(AuxVarString<'a>),
    HwCap(usize),
    Clktck(usize),
    Secure(bool),
    BasePlatform(AuxVarString<'a>),
    Random([u8; 16]),
    HwCap2(usize),
    ExecFn(AuxVarString<'a>),
    Sysinfo(*const u8),
    SysinfoEhdr(*const u8),
    L1iCacheSize(usize),
    L1iCacheGeometry(usize),
    L1dCacheSize(usize),
    L1dCacheGeometry(usize),
    L2CacheSize(usize),
    L2CacheGeometry(usize),
    L3CacheSize(usize),
    L3CacheGeometry(usize),
    MinSigStkSz(usize),
}

High-level version of an auxiliary vector (auxv) entry. Also called Auxiliary Variable or AT Variable.

The data/payload is either an immediate value embedded into the enum variant or a pointer into the auxv data area. The enum variant’s payload does not necessarily correspond to the ABI.

More Info

• https://elixir.bootlin.com/linux/latest/source/include/uapi/linux/auxvec.h
• https://elixir.bootlin.com/linux/latest/source/fs/binfmt_elf.c#L259
• https://man7.org/linux/man-pages/man3/getauxval.3.html
• https://lwn.net/Articles/631631/

Variants

Null

Entry with payload for type AuxVarType::Null.

Ignore

Entry with payload for type AuxVarType::Ignore.

ExecFd(usize)

Entry with payload for type AuxVarType::ExecFd.

Phdr(*const u8)

Entry with payload for type AuxVarType::Phdr.

Phent(usize)

Entry with payload for type AuxVarType::Phent.

Phnum(usize)

Entry with payload for type AuxVarType::Phnum.

Pagesz(usize)

Entry with payload for type AuxVarType::Pagesz.

Base(*const u8)

Entry with payload for type AuxVarType::Base.

Flags(AuxVarFlags)

Entry with payload for type AuxVarType::Flags.

Entry(*const u8)

Entry with payload for type AuxVarType::Entry.

NotElf(bool)

Entry with payload for type AuxVarType::NotElf.

Uid(usize)

Entry with payload for type AuxVarType::Uid.

EUid(usize)

Entry with payload for type AuxVarType::EUid.

Gid(usize)

Entry with payload for type AuxVarType::Gid.

EGid(usize)

Entry with payload for type AuxVarType::EGid.

Platform(AuxVarString<'a>)

Entry with payload for type AuxVarType::Platform.

HwCap(usize)

Entry with payload for type AuxVarType::HwCap.

Clktck(usize)

Entry with payload for type AuxVarType::Clktck.

Secure(bool)

Entry with payload for type AuxVarType::Secure.

BasePlatform(AuxVarString<'a>)

Entry with payload for type AuxVarType::BasePlatform.

Random([u8; 16])

Entry with payload for type AuxVarType::Random.

HwCap2(usize)

Entry with payload for type AuxVarType::HwCap2.

ExecFn(AuxVarString<'a>)

Entry with payload for type AuxVarType::ExecFn.

Sysinfo(*const u8)

Entry with payload for type AuxVarType::Sysinfo.

SysinfoEhdr(*const u8)

Entry with payload for type AuxVarType::SysinfoEhdr.

L1iCacheSize(usize)

Entry with payload for type AuxVarType::L1iCacheSize.

L1iCacheGeometry(usize)

Entry with payload for type AuxVarType::L1iCacheGeometry.

L1dCacheSize(usize)

Entry with payload for type AuxVarType::L1dCacheSize.

L1dCacheGeometry(usize)

Entry with payload for type AuxVarType::L1dCacheGeometry.

L2CacheSize(usize)

Entry with payload for type AuxVarType::L2CacheSize.

L2CacheGeometry(usize)

Entry with payload for type AuxVarType::L2CacheGeometry.

L3CacheSize(usize)

Entry with payload for type AuxVarType::L3CacheSize.

L3CacheGeometry(usize)

Entry with payload for type AuxVarType::L3CacheGeometry.

MinSigStkSz(usize)

Entry with payload for type AuxVarType::MinSigStkSz.

Implementations

impl<'a> AuxVar<'a>

pub const fn key(&self) -> AuxVarType

Returns the AuxVarType this aux var corresponds to.

Examples found in repository

examples/linux_print_layout.rs (line 69)

fn main(argc: isize, argv: *const *const u8) -> isize {
    let buffer = unsafe {
        // 100 KiB, reasonably big.
        // On my Linux machine, the structure needs 23 KiB
        slice::from_raw_parts(argv.cast::<u8>(), 0x19000)
    };

    let parsed = StackLayoutRef::new(buffer, Some(argc as usize));

    println!("There are {} arguments.", parsed.argc());
    println!("  argv (raw)");
    for (i, arg) in parsed.argv_raw_iter().enumerate() {
        println!("    [{i}] @ {arg:?}");
    }
    println!("  argv");
    // SAFETY: The pointers are valid in the address space of this process.
    for (i, arg) in unsafe { parsed.argv_iter() }.enumerate() {
        println!("    [{i}] {arg:?}");
    }

    println!("There are {} environment variables.", parsed.envc());
    println!("  envv (raw)");
    for (i, env) in parsed.envv_raw_iter().enumerate() {
        println!("    [{i}] {env:?}");
    }
    println!("  envv");
    // SAFETY: The pointers are valid in the address space of this process.
    for (i, env) in unsafe { parsed.envv_iter() }.enumerate() {
        println!("    [{i}] {env:?}");
    }

    println!(
        "There are {} auxiliary vector entries/AT variables.",
        parsed.auxv_raw_iter().count()
    );
    println!("  aux");
    // ptr iter is safe for other address spaces; the other only because here user_addr == write_addr
    for aux in unsafe { parsed.auxv_iter() } {
        if aux.key().value_in_data_area() {
            println!("    {:?} => @ {:?}", aux.key(), aux);
        } else {
            println!("    {:?} => {:?}", aux.key(), aux);
        }
    }

    0
}

pub fn value_raw(&self) -> usize

Transforms any inner value into it’s corresponding serialized usize value.

This only works for variants that do not reference data exceeding the size of an usize.

pub const fn value_integer(&self) -> Option<usize>

Returns a value if the corresponding entry corresponds to a basic value/integer, and not a pointer, flags, or a boolean.

pub const fn value_flags(&self) -> Option<AuxVarFlags>

Returns the AuxVarFlags if the corresponding entry is of type AuxVarType::Flags.

pub const fn value_boolean(&self) -> Option<bool>

Returns a value if the corresponding entry corresponds to a boolean, and not a pointer, flags, or a basic value/integer.

pub const fn value_ptr(&self) -> Option<*const u8>

Returns a value if the corresponding entry corresponds to a pointer, and not a boolean, flags, or a basic value/integer.

This only affects entries that point to memory outside the stack layout, i.e., the aux vector data area.

pub fn value_payload_bytes(&'a self) -> Option<&'a [u8]>

Returns a value, if the corresponding auxiliary vector entry references data in the auxiliary vector data area of the data structure. This returns only something for AuxVarType::Random.

This function is safe, because the creation during parsing already guarantee memory safety (the addresses are accessed).

pub const fn value_payload_str(&'a self) -> Option<&'a AuxVarString<'a>>

Returns a value, if the corresponding auxiliary vector entry references data in the auxiliary vector data area of the data structure. This returns only something for AuxVarType::Random.

This function is safe, because the creation during parsing already guarantee memory safety (the addresses are accessed).

Trait Implementations

impl<'a> Clone for AuxVar<'a>

fn clone(&self) -> AuxVar<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for AuxVar<'a>

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

Formats the value using the given formatter.

impl<'a> Ord for AuxVar<'a>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for AuxVar<'a>

fn eq(&self, other: &AuxVar<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialOrd for AuxVar<'a>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Eq for AuxVar<'a>

impl<'a> StructuralPartialEq for AuxVar<'a>