Struct ExecRecord 

pub struct ExecRecord {
    pub exe: PathBuf,
    /* private fields */
}

The image a process executes.

Fields

exe: PathBuf

The image’s canonical path, as the process’s root directory shows it: what readlink("/proc/self/exe") returns while the file is there.

Implementations

impl ExecRecord

pub fn resolve(root: &Path, cwd: &Path, path: &Path) -> Option<Self>

The image an execve of path runs, as the kernel finds it: path taken from the working directory cwd, every symbolic link followed, and for a script the interpreter its #! line names, level by level, as /proc/<pid>/exe names the interpreter. root is the process’s root directory as the caller sees it, and cwd is the working directory below it, absolute.

None where the kernel would refuse the exec (no such file, a malformed #! line, too many interpreter levels), where the caller cannot look the path up, and for a file the caller cannot read, which the kernel may still run (an execute-only binary, or a script whose #! line the kernel reads without a permission check): the link is then the kernel’s to answer. A resolution can still be wrong where the kernel runs a file differently (a binfmt_misc handler) or the caller sees another filesystem; tool_global checks every record against the kernel’s own link after the exec.

pub fn resolve_from( root: &Path, cwd: Option<&Path>, path: &Path, ) -> Option<Self>

Self::resolve for a caller whose working directory may be unknown (cwd is None): then None wherever the kernel would look a relative path up from it (a relative path, or a script whose #! line names a relative interpreter).

pub fn at(root: &Path, found: &Path) -> Option<Self>

The record of the image at found, a canonical path the caller sees below root, as that file is now.

pub fn identity(&self) -> (u64, u64)

The image file’s device and inode when it was exec’d.

pub fn is_present(&self, root: &Path) -> bool

Whether the image’s file is still at its path, untouched, for a process whose root directory the caller sees at root: the same inode, with the link count and change time it had at the exec. A rename or link of the image since, or a change of its mode, reads as absent, so the caller refuses rather than name a path Linux’s link might not.

pub fn names_path_exactly(&self, root: &Path) -> bool

Whether the image’s path still names exactly the file the process executes, as Linux’s exe link renders it (d_path of the image’s dentry), for a process whose root directory the caller sees at root: the file is untouched at its path (Self::is_present), and every directory above it is the one that was there at the exec (its device and inode, not following a symbolic link). A directory has one dentry, so the same directory inode at a path is that path’s dentry, and the same untouched file in the same directory under the same name is the same dentry: a rename of the image or of any directory above it, another directory or a symbolic link put at one of their paths, and a hard link of the image put back at its path all read as not exact. (Mounts are refused in the guest.)

Trait Implementations

impl Clone for ExecRecord

fn clone(&self) -> ExecRecord

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExecRecord

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExecRecord

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ExecRecord

impl PartialEq for ExecRecord

fn eq(&self, other: &ExecRecord) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ExecRecord

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ExecRecord