Struct MapRange

pub struct MapRange {
    pub offset: usize,
    pub dev: String,
    pub flags: String,
    pub inode: usize,
    /* private fields */
}

A struct representing a single virtual memory region.

While this structure is only for Linux, the macOS, Windows, and FreeBSD variants have identical exposed methods

Fields

offset: usize

dev: String

flags: String

inode: usize

Implementations

impl MapRange

pub fn size(&self) -> usize

Returns the size of this MapRange in bytes

Examples found in repository

examples/print_maps.rs (line 26)

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let pid = if args.len() > 1 {
        args[1].parse().expect("invalid pid")
    } else {
        panic!("Usage: print_maps <PID>");
    };

    println!(
        "{:^30} {:^16} {:^7} {}",
        "ADDRESSES", "SIZE", "MODES", "PATH"
    );

    let empty_path = std::path::Path::new("");
    let maps = proc_maps::get_process_maps(pid).expect("failed to get proc maps");
    for map in maps {
        let r_flag = if map.is_read() { "R" } else { "-" };
        let w_flag = if map.is_write() { "W" } else { "-" };
        let x_flag = if map.is_exec() { "X" } else { "-" };
        let filename = map.filename().unwrap_or(empty_path).to_str().unwrap_or("-");
        println!(
            "{:>30} {:>16} [{} {} {}] {}",
            format!("{:#x}-{:#x}", map.start(), map.start() + map.size()),
            map.size(),
            r_flag,
            w_flag,
            x_flag,
            filename,
        );
    }
}

pub fn start(&self) -> usize

Returns the address this MapRange starts at

Examples found in repository

examples/print_maps.rs (line 26)

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let pid = if args.len() > 1 {
        args[1].parse().expect("invalid pid")
    } else {
        panic!("Usage: print_maps <PID>");
    };

    println!(
        "{:^30} {:^16} {:^7} {}",
        "ADDRESSES", "SIZE", "MODES", "PATH"
    );

    let empty_path = std::path::Path::new("");
    let maps = proc_maps::get_process_maps(pid).expect("failed to get proc maps");
    for map in maps {
        let r_flag = if map.is_read() { "R" } else { "-" };
        let w_flag = if map.is_write() { "W" } else { "-" };
        let x_flag = if map.is_exec() { "X" } else { "-" };
        let filename = map.filename().unwrap_or(empty_path).to_str().unwrap_or("-");
        println!(
            "{:>30} {:>16} [{} {} {}] {}",
            format!("{:#x}-{:#x}", map.start(), map.start() + map.size()),
            map.size(),
            r_flag,
            w_flag,
            x_flag,
            filename,
        );
    }
}

pub fn filename(&self) -> Option<&Path>

Returns the filename of the loaded module

Examples found in repository

examples/print_maps.rs (line 23)

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let pid = if args.len() > 1 {
        args[1].parse().expect("invalid pid")
    } else {
        panic!("Usage: print_maps <PID>");
    };

    println!(
        "{:^30} {:^16} {:^7} {}",
        "ADDRESSES", "SIZE", "MODES", "PATH"
    );

    let empty_path = std::path::Path::new("");
    let maps = proc_maps::get_process_maps(pid).expect("failed to get proc maps");
    for map in maps {
        let r_flag = if map.is_read() { "R" } else { "-" };
        let w_flag = if map.is_write() { "W" } else { "-" };
        let x_flag = if map.is_exec() { "X" } else { "-" };
        let filename = map.filename().unwrap_or(empty_path).to_str().unwrap_or("-");
        println!(
            "{:>30} {:>16} [{} {} {}] {}",
            format!("{:#x}-{:#x}", map.start(), map.start() + map.size()),
            map.size(),
            r_flag,
            w_flag,
            x_flag,
            filename,
        );
    }
}

pub fn is_exec(&self) -> bool

Returns whether this range contains executable code

Examples found in repository

examples/print_maps.rs (line 22)

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let pid = if args.len() > 1 {
        args[1].parse().expect("invalid pid")
    } else {
        panic!("Usage: print_maps <PID>");
    };

    println!(
        "{:^30} {:^16} {:^7} {}",
        "ADDRESSES", "SIZE", "MODES", "PATH"
    );

    let empty_path = std::path::Path::new("");
    let maps = proc_maps::get_process_maps(pid).expect("failed to get proc maps");
    for map in maps {
        let r_flag = if map.is_read() { "R" } else { "-" };
        let w_flag = if map.is_write() { "W" } else { "-" };
        let x_flag = if map.is_exec() { "X" } else { "-" };
        let filename = map.filename().unwrap_or(empty_path).to_str().unwrap_or("-");
        println!(
            "{:>30} {:>16} [{} {} {}] {}",
            format!("{:#x}-{:#x}", map.start(), map.start() + map.size()),
            map.size(),
            r_flag,
            w_flag,
            x_flag,
            filename,
        );
    }
}

pub fn is_write(&self) -> bool

Returns whether this range contains writeable memory

Examples found in repository

examples/print_maps.rs (line 21)

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let pid = if args.len() > 1 {
        args[1].parse().expect("invalid pid")
    } else {
        panic!("Usage: print_maps <PID>");
    };

    println!(
        "{:^30} {:^16} {:^7} {}",
        "ADDRESSES", "SIZE", "MODES", "PATH"
    );

    let empty_path = std::path::Path::new("");
    let maps = proc_maps::get_process_maps(pid).expect("failed to get proc maps");
    for map in maps {
        let r_flag = if map.is_read() { "R" } else { "-" };
        let w_flag = if map.is_write() { "W" } else { "-" };
        let x_flag = if map.is_exec() { "X" } else { "-" };
        let filename = map.filename().unwrap_or(empty_path).to_str().unwrap_or("-");
        println!(
            "{:>30} {:>16} [{} {} {}] {}",
            format!("{:#x}-{:#x}", map.start(), map.start() + map.size()),
            map.size(),
            r_flag,
            w_flag,
            x_flag,
            filename,
        );
    }
}

pub fn is_read(&self) -> bool

Returns whether this range contains readable memory

Examples found in repository

examples/print_maps.rs (line 20)

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let pid = if args.len() > 1 {
        args[1].parse().expect("invalid pid")
    } else {
        panic!("Usage: print_maps <PID>");
    };

    println!(
        "{:^30} {:^16} {:^7} {}",
        "ADDRESSES", "SIZE", "MODES", "PATH"
    );

    let empty_path = std::path::Path::new("");
    let maps = proc_maps::get_process_maps(pid).expect("failed to get proc maps");
    for map in maps {
        let r_flag = if map.is_read() { "R" } else { "-" };
        let w_flag = if map.is_write() { "W" } else { "-" };
        let x_flag = if map.is_exec() { "X" } else { "-" };
        let filename = map.filename().unwrap_or(empty_path).to_str().unwrap_or("-");
        println!(
            "{:>30} {:>16} [{} {} {}] {}",
            format!("{:#x}-{:#x}", map.start(), map.start() + map.size()),
            map.size(),
            r_flag,
            w_flag,
            x_flag,
            filename,
        );
    }
}

Trait Implementations

impl Clone for MapRange

fn clone(&self) -> MapRange

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MapRange

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

Formats the value using the given formatter.

impl PartialEq for MapRange

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