Struct ProcessMemoryMap 

pub struct ProcessMemoryMap {
    pub regions: Vec<MemoryRegion>,
    pub total_mapped: usize,
    pub executable_regions: usize,
    pub writable_regions: usize,
    pub private_regions: usize,
}

Represents the complete memory map of a debugged process

A ProcessMemoryMap contains a collection of memory regions and summary statistics about the process’s memory usage.

Examples

use coreminer::memorymap::ProcessMemoryMap;
use proc_maps::get_process_maps;

// Get the memory map for the current process
let maps = get_process_maps(std::process::id() as i32).unwrap();
let memory_map = ProcessMemoryMap::from(maps);

// Print the memory map summary
println!("Total mapped memory: {} bytes", memory_map.total_mapped);
println!("Number of regions: {}", memory_map.regions.len());
println!("Executable regions: {}", memory_map.executable_regions);
println!("Writable regions: {}", memory_map.writable_regions);

// Iterate through regions
for region in &memory_map.regions {
    println!("Region at {:x} - {:x}: {} bytes",
             region.start_address.usize(),
             region.end_address.usize(),
             region.size);
}

Fields

regions: Vec<MemoryRegion>

List of memory regions in the process

total_mapped: usize

Total amount of mapped memory in bytes

executable_regions: usize

Number of executable memory regions

writable_regions: usize

Number of writable memory regions

private_regions: usize

Number of private memory regions

Trait Implementations

impl Clone for ProcessMemoryMap

fn clone(&self) -> ProcessMemoryMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProcessMemoryMap

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

Formats the value using the given formatter.

impl Display for ProcessMemoryMap

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

Formats the value using the given formatter.

impl From<Vec<MapRange>> for ProcessMemoryMap

fn from(ranges: Vec<MapRange>) -> Self

Converts to this type from the input type.

impl Serialize for ProcessMemoryMap

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

where __S: Serializer,

Serialize this value into the given Serde serializer.