Module procfs::process

source ·
Expand description

Functions and structs related to process information

The primary source of data for functions in this module is the files in a /proc/<pid>/ directory. If you have a process ID, you can use Process::new(pid), otherwise you can get a list of all running processes using all_processes().

In case you have procfs filesystem mounted to a location other than /proc, use Process::new_with_root().

Examples

Here’s a small example that prints out all processes that are running on the same tty as the calling process. This is very similar to what “ps” does in its default mode. You can run this example yourself with:

cargo run –example=ps

let me = procfs::process::Process::myself().unwrap();
let me_stat = me.stat().unwrap();
let tps = procfs::ticks_per_second();

println!("{: >10} {: <8} {: >8} {}", "PID", "TTY", "TIME", "CMD");

let tty = format!("pty/{}", me_stat.tty_nr().1);
for prc in procfs::process::all_processes().unwrap() {
    if let Ok(stat) = prc.unwrap().stat() {
        if stat.tty_nr == me_stat.tty_nr {
            // total_time is in seconds
            let total_time =
                (stat.utime + stat.stime) as f32 / (tps as f32);
            println!(
                "{: >10} {: <8} {: >8} {}",
                stat.pid, tty, total_time, stat.comm
            );
        }
    }
}

Here’s a simple example of how you could get the total memory used by the current process. There are several ways to do this. For a longer example, see the examples/self_memory.rs file in the git repository. You can run this example with:

cargo run –example=self_memory

let me = Process::myself().unwrap();
let me_stat = me.stat().unwrap();
let page_size = procfs::page_size();

println!("== Data from /proc/self/stat:");
println!("Total virtual memory used: {} bytes", me_stat.vsize);
println!("Total resident set: {} pages ({} bytes)", me_stat.rss, me_stat.rss as u64 * page_size);

Structs

  • CoredumpFlags
    See the coredump_filter() method.
  • FDInfo
    See the Process::fd() method
  • FDPermissions
    The mode (read/write permissions) for an open file descriptor
  • FDsIter
    The result of Process::fd, iterates over all fds in a process
  • Io
    This struct contains I/O statistics for the process, built from /proc/<pid>/io
  • Limit
  • Limits
    Process limits
  • MMPermissions
    The permissions a process has on memory map entries.
  • MMapExtension
    Represents the information about a specific mapping as presented in /proc/<pid>/smaps
  • MemoryMap
    Represents an entry in a /proc/<pid>/maps or /proc/<pid>/smaps file.
  • MemoryMaps
    Represents all entries in a /proc/<pid>/maps or /proc/<pid>/smaps file.
  • MemoryPageFlags
    Represents the fields and flags in a page table entry for a memory page.
  • MountInfo
    Information about a specific mount in a process’s mount namespace.
  • MountInfos
    Information about a all mounts in a process’s mount namespace.
  • MountNFSStatistics
    Only NFS mounts provide additional statistics in MountStat entries.
  • MountStat
    A single entry in MountStats.
  • MountStats
    Mount information from /proc/<pid>/mountstats.
  • NFSByteCounter
    Represents NFS data from /proc/<pid>/mountstats under the section bytes.
  • NFSEventCounter
    Represents NFS data from /proc/<pid>/mountstats under the section events.
  • NFSOperationStat
    Represents NFS data from /proc/<pid>/mountstats under the section of per-op statistics.
  • NFSServerCaps
  • Namespace
    Information about a namespace
  • Namespaces
    All namespaces of a process.
  • PageMap
    Parses page table entries accessing /proc/<pid>/pagemap.
  • Pfn
    A Page Frame Number, representing a 4 kiB physical memory page
  • Process
    Represents a process in /proc/<pid>.
  • ProcessesIter
    An iterator over all processes in the system.
  • Schedstat
    Provides scheduler statistics of the process, based on the /proc/<pid>/schedstat file.
  • SmapsRollup
  • Stat
    Status information about the process, based on the /proc/<pid>/stat file.
  • StatFlags
    Kernel flags for a process
  • StatM
    Provides information about memory usage, measured in pages.
  • Status
    Status information about the process, based on the /proc/<pid>/status file.
  • SwapPageFlags
    Represents the fields and flags in a page table entry for a swapped page.
  • Task
    A task (aka Thread) inside of a Process
  • TasksIter
    The result of Process::tasks, iterates over all tasks in a process
  • VmFlags
    Represents the kernel flags associated with the virtual memory area. The names of these flags are just those you’ll find in the man page, but in upper case.

Enums

  • ClearRefs
    Clearing the PG_Referenced and ACCESSED/YOUNG bits provides a method to measure approximately how much memory a process is using. One first inspects the values in the “Referenced” fields for the VMAs shown in /proc/[pid]/smaps to get an idea of the memory footprint of the process. One then clears the PG_Referenced and ACCESSED/YOUNG bits and, after some measured time interval, once again inspects the values in the “Referenced” fields to get an idea of the change in memory footprint of the process during the measured interval. If one is interested only in inspecting the selected mapping types, then the value 2 or 3 can be used instead of 1.
  • FDTarget
    Describes a file descriptor opened by a process.
  • LimitValue
  • MMapPath
  • MountOptFields
    Optional fields used in MountInfo
  • PageInfo
    Represents a page table entry in /proc/<pid>/pagemap.
  • ProcState
    Represents the state of a process.

Functions

Type Aliases