Enum auxtype

#[non_exhaustive]
#[repr(u32)]
pub enum auxtype {
    ARGDATA = 256,
    ARGDATALEN = 257,
    BASE = 7,
    CANARY = 258,
    CANARYLEN = 259,
    NCPUS = 260,
    NULL = 0,
    PAGESZ = 6,
    PHDR = 3,
    PHNUM = 4,
    PID = 263,
    SYSINFO_EHDR = 262,
    TID = 261,
}

Enumeration describing the kind of value stored in auxv.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ARGDATA = 256

Base address of the binary argument data provided to proc_exec().

ARGDATALEN = 257

Length of the binary argument data provided to proc_exec().

BASE = 7

Base address at which the executable is placed in memory.

CANARY = 258

Base address of a buffer of random data that may be used for non-cryptographic purposes, for example as a canary for stack smashing protection.

CANARYLEN = 259

Length of a buffer of random data that may be used for non-cryptographic purposes, for example as a canary for stack smashing protection.

NCPUS = 260

Number of CPUs that the system this process is running on has.

NULL = 0

Terminator of the auxiliary vector.

PAGESZ = 6

Smallest memory object size for which individual memory protection controls can be configured.

PHDR = 3

Address of the first ELF program header of the executable.

PHNUM = 4

Number of ELF program headers of the executable.

PID = 263

Identifier of the process.

This environment does not provide any simple numerical process identifiers, for the reason that these are not useful in distributed contexts. Instead, processes are identified by a UUID.

This record should point to sixteen bytes of binary data, containing a version 4 UUID (fully random).

SYSINFO_EHDR = 262

Address of the ELF header of the vDSO.

The vDSO is a shared library that is mapped in the address space of the process. It provides entry points for every system call supported by the environment, all having a corresponding symbol that is prefixed with cloudabi_sys_. System calls should be invoked through these entry points.

The first advantage of letting processes call into a vDSO to perform system calls instead of raising hardware traps is that it allows for easy emulation of executables on top of existing operating systems. The second advantage is that in cases where an operating system provides native support for CloudABI executables, it may still implement partial userspace implementations of these system calls to improve performance (e.g., clock_time_get()). It also provides a more dynamic way of adding, removing or replacing system calls.

TID = 261

Thread ID of the initial thread of the process.

Trait Implementations

impl Clone for auxtype

fn clone(&self) -> auxtype

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for auxtype

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

Formats the value using the given formatter.

impl Hash for auxtype

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for auxtype

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

impl Eq for auxtype

impl StructuralPartialEq for auxtype