use std::ops::Range;
use std::os::unix::ffi::OsStrExt;
use bitflags::bitflags;
use crate::error::{Error, Result};
use crate::util::parse;
bitflags! {
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct MapPermissions: u8 {
const READ = 1 << 0;
const WRITE = 1 << 1;
const EXEC = 1 << 2;
const SHARED = 1 << 3;
const PRIVATE = 1 << 4;
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MapPathname {
Path(std::path::PathBuf),
Heap,
Stack,
Vdso,
Vsyscall,
Vvar,
Anonymous,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MemoryMap {
pub address: Range<u64>,
pub perms: MapPermissions,
pub offset: u64,
pub device: (u32, u32),
pub inode: u64,
pub pathname: MapPathname,
}
#[derive(Debug, Clone)]
pub struct MemoryMapDetail {
pub address: Range<u64>,
pub perms: MapPermissions,
pub offset: u64,
pub device: (u32, u32),
pub inode: u64,
pub pathname: MapPathname,
pub size_kb: u64,
pub rss_kb: u64,
pub pss_kb: u64,
pub shared_clean_kb: u64,
pub shared_dirty_kb: u64,
pub private_clean_kb: u64,
pub private_dirty_kb: u64,
pub referenced_kb: u64,
pub anonymous_kb: u64,
pub swap_kb: u64,
}
#[derive(Debug, Clone)]
pub struct SmapsRollup {
pub rss_kb: u64,
pub pss_kb: u64,
pub shared_clean_kb: u64,
pub shared_dirty_kb: u64,
pub private_clean_kb: u64,
pub private_dirty_kb: u64,
pub referenced_kb: u64,
pub anonymous_kb: u64,
pub swap_kb: u64,
}
impl SmapsRollup {
pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
let mut rollup = SmapsRollup {
rss_kb: 0,
pss_kb: 0,
shared_clean_kb: 0,
shared_dirty_kb: 0,
private_clean_kb: 0,
private_dirty_kb: 0,
referenced_kb: 0,
anonymous_kb: 0,
swap_kb: 0,
};
for line in bytes.split(|&b| b == b'\n').filter(|l| !l.is_empty()) {
let (key, value) = match parse::parse_key_value_line(line) {
Some(kv) => kv,
None => continue,
};
let val = parse::trim_start(value)
.split(|&b| b == b' ' || b == b'\t')
.next()
.and_then(|t| parse::parse_dec_u64(t).ok())
.unwrap_or(0);
match key {
b"Rss" => rollup.rss_kb = val,
b"Pss" => rollup.pss_kb = val,
b"Shared_Clean" => rollup.shared_clean_kb = val,
b"Shared_Dirty" => rollup.shared_dirty_kb = val,
b"Private_Clean" => rollup.private_clean_kb = val,
b"Private_Dirty" => rollup.private_dirty_kb = val,
b"Referenced" => rollup.referenced_kb = val,
b"Anonymous" => rollup.anonymous_kb = val,
b"Swap" => rollup.swap_kb = val,
_ => {}
}
}
Ok(rollup)
}
}
impl MemoryMap {
pub fn parse_all(bytes: &[u8]) -> Result<Vec<Self>> {
let mut maps = Vec::new();
for line in bytes.split(|&b| b == b'\n').filter(|l| !l.is_empty()) {
maps.push(Self::parse_line(line)?);
}
Ok(maps)
}
fn parse_line(line: &[u8]) -> Result<Self> {
let fields = parse::SplitFields::<8>::new(line);
if fields.len() < 5 {
return Err(Error::Parse {
path: std::path::PathBuf::from("<maps>"),
line: 0,
msg: "not enough fields",
});
}
let address = parse_address_range(fields[0])?;
let perms = parse_permissions(fields[1])?;
let offset = parse::parse_hex_u64(fields[2])?;
let device = parse_device(fields[3])?;
let inode = parse::parse_dec_u64(fields[4])?;
let pathname = if fields.len() > 5 {
parse_pathname(&fields[5..])
} else {
MapPathname::Anonymous
};
Ok(MemoryMap {
address,
perms,
offset,
device,
inode,
pathname,
})
}
}
impl MemoryMapDetail {
pub fn parse_all(bytes: &[u8]) -> Result<Vec<Self>> {
let mut details = Vec::new();
let mut current: Option<MemoryMapDetail> = None;
for line in bytes.split(|&b| b == b'\n').filter(|l| !l.is_empty()) {
if line.first().is_some_and(|b| b.is_ascii_hexdigit()) && line.contains(&b'-') {
if let Some(detail) = current.take() {
details.push(detail);
}
current = Some(MemoryMapDetail::from_map_line(line)?);
} else if let Some(ref mut detail) = current {
detail.parse_detail_line(line);
}
}
if let Some(detail) = current {
details.push(detail);
}
Ok(details)
}
fn from_map_line(line: &[u8]) -> Result<Self> {
let map = MemoryMap::parse_line(line)?;
Ok(MemoryMapDetail {
address: map.address,
perms: map.perms,
offset: map.offset,
device: map.device,
inode: map.inode,
pathname: map.pathname,
size_kb: 0,
rss_kb: 0,
pss_kb: 0,
shared_clean_kb: 0,
shared_dirty_kb: 0,
private_clean_kb: 0,
private_dirty_kb: 0,
referenced_kb: 0,
anonymous_kb: 0,
swap_kb: 0,
})
}
fn parse_detail_line(&mut self, line: &[u8]) {
let (key, value) = match parse::parse_key_value_line(line) {
Some(kv) => kv,
None => return,
};
let val = parse::trim_start(value)
.split(|&b| b == b' ' || b == b'\t')
.next()
.and_then(|t| parse::parse_dec_u64(t).ok())
.unwrap_or(0);
match key {
b"Size" => self.size_kb = val,
b"Rss" => self.rss_kb = val,
b"Pss" => self.pss_kb = val,
b"Shared_Clean" => self.shared_clean_kb = val,
b"Shared_Dirty" => self.shared_dirty_kb = val,
b"Private_Clean" => self.private_clean_kb = val,
b"Private_Dirty" => self.private_dirty_kb = val,
b"Referenced" => self.referenced_kb = val,
b"Anonymous" => self.anonymous_kb = val,
b"Swap" => self.swap_kb = val,
_ => {}
}
}
}
fn parse_address_range(s: &[u8]) -> Result<Range<u64>> {
let dash = parse::memchr(b'-', s).ok_or_else(|| Error::Parse {
path: std::path::PathBuf::from("<maps>"),
line: 0,
msg: "missing dash in address range",
})?;
let start = parse::parse_hex_u64(&s[..dash])?;
let end = parse::parse_hex_u64(&s[dash + 1..])?;
Ok(start..end)
}
fn parse_permissions(s: &[u8]) -> Result<MapPermissions> {
if s.len() < 4 {
return Err(Error::Parse {
path: std::path::PathBuf::from("<maps>"),
line: 0,
msg: "permission string too short",
});
}
let mut perms = MapPermissions::empty();
if s[0] == b'r' {
perms |= MapPermissions::READ;
}
if s[1] == b'w' {
perms |= MapPermissions::WRITE;
}
if s[2] == b'x' {
perms |= MapPermissions::EXEC;
}
if s[3] == b's' {
perms |= MapPermissions::SHARED;
} else if s[3] == b'p' {
perms |= MapPermissions::PRIVATE;
}
Ok(perms)
}
fn parse_device(s: &[u8]) -> Result<(u32, u32)> {
let colon = parse::memchr(b':', s).ok_or_else(|| Error::Parse {
path: std::path::PathBuf::from("<maps>"),
line: 0,
msg: "missing colon in device",
})?;
let major = parse::parse_hex_u64(&s[..colon])? as u32;
let minor = parse::parse_hex_u64(&s[colon + 1..])? as u32;
Ok((major, minor))
}
fn parse_pathname(fields: &[&[u8]]) -> MapPathname {
match fields[0] {
b"[heap]" => MapPathname::Heap,
b"[stack]" => MapPathname::Stack,
b"[vdso]" => MapPathname::Vdso,
b"[vsyscall]" => MapPathname::Vsyscall,
b"[vvar]" => MapPathname::Vvar,
_ => MapPathname::Path(std::path::PathBuf::from(std::ffi::OsStr::from_bytes(
fields[0],
))),
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used)]
use super::*;
#[test]
fn device_is_parsed_as_hex() {
assert_eq!(parse_device(b"103:02").unwrap(), (0x103, 0x2));
assert_eq!(parse_device(b"00:00").unwrap(), (0x0, 0x0));
assert_eq!(parse_device(b"00:2c").unwrap(), (0x0, 0x2c));
assert_eq!(parse_device(b"fd:01").unwrap(), (0xfd, 0x1));
}
#[test]
fn maps_line_with_hex_device_parses() {
let line = b"7f0000000000-7f0000002000 r-xp 00001000 00:2c 396620 /usr/lib/libfoo.so";
let map = MemoryMap::parse_line(line).unwrap();
assert_eq!(map.device, (0x0, 0x2c));
assert_eq!(map.inode, 396620);
}
}