Enum AuxVarType

#[repr(usize)]
pub enum AuxVarType {
    Null = 0,
    Ignore = 1,
    ExecFd = 2,
    Phdr = 3,
    Phent = 4,
    Phnum = 5,
    Pagesz = 6,
    Base = 7,
    Flags = 8,
    Entry = 9,
    NotElf = 10,
    Uid = 11,
    EUid = 12,
    Gid = 13,
    EGid = 14,
    Platform = 15,
    HwCap = 16,
    Clktck = 17,
    Secure = 23,
    BasePlatform = 24,
    Random = 25,
    HwCap2 = 26,
    ExecFn = 31,
    Sysinfo = 32,
    SysinfoEhdr = 33,
    L1iCacheSize = 40,
    L1iCacheGeometry = 41,
    L1dCacheSize = 42,
    L1dCacheGeometry = 43,
    L2CacheSize = 44,
    L2CacheGeometry = 45,
    L3CacheSize = 46,
    L3CacheGeometry = 47,
    MinSigStkSz = 51,
}

All types of auxiliary variables that Linux supports for the initial stack. Also called “AT”-variables in Linux source code.

According to some Linux code comments, 0-17 are architecture independent The ones above and including 32 are for x86_64. Values above 40 are for power PC.

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

Variants

Null = 0

end of vector

Ignore = 1

entry should be ignored

ExecFd = 2

file descriptor of program

Phdr = 3

program headers for program

Phent = 4

size of program header entry

Phnum = 5

number of program headers

Pagesz = 6

system page size

Base = 7

The base address of the program interpreter (usually, the dynamic linker).

Flags = 8

Flags that apply on the whole auxiliary vector. See crate::AuxVarFlags.

Entry = 9

entry point of program

NotElf = 10

program is not ELF

Uid = 11

real uid

EUid = 12

effective uid

Gid = 13

real gid

EGid = 14

effective gid

Platform = 15

string identifying CPU for optimizations

HwCap = 16

Arch dependent hints at CPU capabilities. On x86_64 these are the CPUID features.

Clktck = 17

frequency at which times() increments

Secure = 23

secure mode boolean

BasePlatform = 24

string identifying real platform, may differ from AtPlatform.

Random = 25

address of 16 random bytes

HwCap2 = 26

extension of AtHwcap

ExecFn = 31

filename of program, for example “./my_executable\0”

Sysinfo = 32

The entry point to the system call function in the vDSO. Not present/needed on all architectures (e.g., absent on x86-64).

SysinfoEhdr = 33

The address of a page containing the virtual Dynamic Shared Object (vDSO) that the kernel creates in order to provide fast implementations of certain system calls.

L1iCacheSize = 40

L1iCacheGeometry = 41

L1dCacheSize = 42

L1dCacheGeometry = 43

L2CacheSize = 44

L2CacheGeometry = 45

L3CacheSize = 46

L3CacheGeometry = 47

MinSigStkSz = 51

Minimal stack size for signal delivery.

Implementations

impl AuxVarType

pub const fn val(self) -> usize

pub const fn value_in_data_area(self) -> bool

If this is true, the value of the key should be interpreted as pointer into the aux vector data area. Otherwise, the value of the key is an immediate value/integer.

Examples found in repository

examples/minimal.rs (line 79)

fn main() {
    let builder = InitialLinuxLibcStackLayoutBuilder::new()
        // can contain terminating zero; not mandatory in the builder
        .add_arg_v("./first_arg\0")
        .add_arg_v("./second_arg")
        .add_env_v("FOO=BAR\0")
        .add_env_v("PATH=/bin")
        .add_aux_v(AuxVar::Clktck(100))
        .add_aux_v(AuxVar::Random([
            1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
        ]))
        .add_aux_v(AuxVar::ExecFn("/usr/bin/foo"))
        .add_aux_v(AuxVar::Platform("x86_64"));

    // memory where we serialize the data structure into
    let mut buf = vec![0; builder.total_size()];

    // assume user stack is at 0x7fff0000
    let user_base_addr = 0x7fff0000;
    unsafe {
        builder.serialize_into_buf(buf.as_mut_slice(), user_base_addr);
    }

    // So far, this is memory safe, as long as the slice is valid memory. No pointers are
    // dereferenced yet.
    let parsed = InitialLinuxLibcStackLayout::from(buf.as_slice());

    println!("There are {} arguments.", parsed.argc());
    println!(
        "There are {} environment variables.",
        parsed.envv_ptr_iter().count()
    );
    println!(
        "There are {} auxiliary vector entries/AT variables.",
        parsed.aux_serialized_iter().count()
    );

    println!("  argv");
    // ptr iter is safe for other address spaces; the other only because here user_addr == write_addr
    for (i, arg) in parsed.argv_ptr_iter().enumerate() {
        println!("    [{}] @ {:?}", i, arg);
    }

    println!("  envp");
    // ptr iter is safe for other address spaces; the other only because here user_addr == write_addr
    for (i, env) in parsed.envv_ptr_iter().enumerate() {
        println!("    [{}] @ {:?}", i, env);
    }

    println!("  aux");
    // ptr iter is safe for other address spaces; the other only because here user_addr == write_addr
    for aux in parsed.aux_serialized_iter() {
        if aux.key().value_in_data_area() {
            println!("    {:?} => @ {:?}", aux.key(), aux.val() as *const u8);
        } else {
            println!("    {:?} => {:?}", aux.key(), aux.val() as *const u8);
        }
    }
}

pub fn value_is_cstr(self) -> bool

Most of the auxiliary vector entries where Self::value_is_cstr is true, represent a null-terminated C-string.

pub const fn data_area_val_size_hint(self) -> Option<usize>

The payload of some AuxVarType is stored in the aux var data area. Some of these data is null-terminated. Some has a fixed size. This helps to find out if there is a fixed size.

Trait Implementations

impl Clone for AuxVarType

fn clone(&self) -> AuxVarType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AuxVarType

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

Formats the value using the given formatter.

impl From<usize> for AuxVarType

fn from(val: usize) -> Self

Converts to this type from the input type.

impl IntoEnumIterator for AuxVarType

const VARIANT_COUNT: usize = 34usize

Number of variants.

type Iterator = AuxVarTypeEnumIterator

Type of the iterator over the variants.

fn into_enum_iter() -> Self::Iterator

Returns an iterator over the variants.

impl Ord for AuxVarType

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 PartialEq for AuxVarType

fn eq(&self, other: &AuxVarType) -> 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 PartialOrd for AuxVarType

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 Copy for AuxVarType

impl Eq for AuxVarType

impl StructuralPartialEq for AuxVarType