diff --git a/src/bin/test.rs b/src/bin/test.rs index df39b286..19daa541 100644 --- a/src/bin/test.rs +++ b/src/bin/test.rs @@ -90,7 +90,8 @@ mod linux { let ppid = getppid().as_raw(); let exe_link = format!("/proc/{}/exe", ppid); let exe_name = std::fs::read_link(exe_link)?.into_os_string(); - let mut dumper = PtraceDumper::new(getppid().as_raw(), STOP_TIMEOUT)?; + let mut dumper = PtraceDumper::new(ppid, STOP_TIMEOUT)?; + dumper.suspend_threads()?; let mut found_exe = None; for (idx, mapping) in dumper.mappings.iter().enumerate() { if mapping.name.as_ref().map(|x| x.into()).as_ref() == Some(&exe_name) { @@ -100,6 +101,7 @@ mod linux { } let idx = found_exe.unwrap(); let id = dumper.elf_identifier_for_mapping_index(idx)?; + dumper.resume_threads()?; assert!(!id.is_empty()); assert!(id.iter().any(|&x| x > 0)); Ok(()) diff --git a/src/linux.rs b/src/linux.rs index b4c5b211..31e21c76 100644 --- a/src/linux.rs +++ b/src/linux.rs @@ -5,6 +5,7 @@ mod android; pub mod app_memory; pub(crate) mod auxv_reader; +pub mod build_id_reader; pub mod crash_context; mod dso_debug; mod dumper_cpu_info; diff --git a/src/linux/build_id_reader.rs b/src/linux/build_id_reader.rs new file mode 100644 index 00000000..94288b24 --- /dev/null +++ b/src/linux/build_id_reader.rs @@ -0,0 +1,319 @@ +use crate::errors::BuildIdReaderError as Error; +use crate::minidump_format::GUID; +use goblin::{ + container::{Container, Ctx, Endian}, + elf, +}; + +const NOTE_SECTION_NAME: &[u8] = b".note.gnu.build-id\0"; + +pub trait ModuleMemory { + type Memory: std::ops::Deref; + + fn read_module_memory(&self, offset: u64, length: u64) -> std::io::Result; +} + +impl<'a> ModuleMemory for &'a [u8] { + type Memory = Self; + + fn read_module_memory(&self, offset: u64, length: u64) -> std::io::Result { + self.get(offset as usize..(offset + length) as usize) + .ok_or_else(|| { + std::io::Error::new( + std::io::ErrorKind::UnexpectedEof, + format!("{} out of bounds", offset + length), + ) + }) + } +} + +fn read(mem: &T, offset: u64, length: u64) -> Result { + mem.read_module_memory(offset, length) + .map_err(|error| Error::ReadModuleMemory { + offset, + length, + error, + }) +} + +fn is_executable_section(header: &elf::SectionHeader) -> bool { + header.sh_type == elf::section_header::SHT_PROGBITS + && header.sh_flags & u64::from(elf::section_header::SHF_ALLOC) != 0 + && header.sh_flags & u64::from(elf::section_header::SHF_EXECINSTR) != 0 +} + +/// Return bytes to use as a build id, computed by hashing the given data. +/// +/// This provides `size_of::` bytes to keep identifiers produced by this function compatible +/// with other build ids. +fn build_id_from_bytes(data: &[u8]) -> Vec { + // Only provide mem::size_of(MDGUID) bytes to keep identifiers produced by this + // function backwards-compatible. + data.chunks(std::mem::size_of::()).fold( + vec![0u8; std::mem::size_of::()], + |mut bytes, chunk| { + bytes + .iter_mut() + .zip(chunk.iter()) + .for_each(|(b, c)| *b ^= *c); + bytes + }, + ) +} + +pub fn read_build_id(module_memory: impl ModuleMemory) -> Result, Error> { + let reader = ElfBuildIdReader::new(module_memory)?; + let program_headers = match reader.read_from_program_headers() { + Ok(v) => return Ok(v), + Err(e) => Box::new(e), + }; + let section = match reader.read_from_section() { + Ok(v) => return Ok(v), + Err(e) => Box::new(e), + }; + let generated = match reader.generate_from_text() { + Ok(v) => return Ok(v), + Err(e) => Box::new(e), + }; + Err(Error::Aggregate { + program_headers, + section, + generated, + }) +} + +pub struct ElfBuildIdReader { + module_memory: T, + header: elf::Header, + context: Ctx, +} + +impl ElfBuildIdReader { + pub fn new(module_memory: T) -> Result { + // We could use `Ctx::default()` (which defaults to the native system), however to be extra + // permissive we'll just use a 64-bit ("Big") context which would result in the largest + // possible header size. + let header_size = elf::Header::size(Ctx::new(Container::Big, Endian::default())); + let header_data = read(&module_memory, 0, header_size as u64)?; + let header = elf::Elf::parse_header(&header_data)?; + let context = Ctx::new(header.container()?, header.endianness()?); + Ok(ElfBuildIdReader { + module_memory, + header, + context, + }) + } + + /// Read the build id from a program header note. + pub fn read_from_program_headers(&self) -> Result, Error> { + if self.header.e_phoff == 0 { + return Err(Error::NoProgramHeaderNote); + } + let program_headers_data = read( + &self.module_memory, + self.header.e_phoff, + self.header.e_phentsize as u64 * self.header.e_phnum as u64, + )?; + let program_headers = elf::ProgramHeader::parse( + &program_headers_data, + 0, + self.header.e_phnum as usize, + self.context, + )?; + for header in program_headers { + if header.p_type != elf::program_header::PT_NOTE { + continue; + } + if let Ok(Some(result)) = + self.find_build_id_note(header.p_offset, header.p_filesz, header.p_align) + { + return Ok(result); + } + } + Err(Error::NoProgramHeaderNote) + } + + /// Read the build id from a notes section. + pub fn read_from_section(&self) -> Result, Error> { + let section_headers = self.read_section_headers()?; + + let strtab_section_header = section_headers + .get(self.header.e_shstrndx as usize) + .ok_or(Error::NoStrTab)?; + + for header in §ion_headers { + let sh_name = header.sh_name as u64; + if sh_name >= strtab_section_header.sh_size { + log::warn!("invalid sh_name offset"); + continue; + } + if sh_name + NOTE_SECTION_NAME.len() as u64 >= strtab_section_header.sh_size { + // This can't be a match. + continue; + } + let name = read( + &self.module_memory, + strtab_section_header.sh_offset + sh_name, + NOTE_SECTION_NAME.len() as u64, + )?; + if NOTE_SECTION_NAME == &*name { + return match self.find_build_id_note( + header.sh_offset, + header.sh_size, + header.sh_addralign, + ) { + Ok(Some(v)) => Ok(v), + Ok(None) => Err(Error::NoSectionNote), + Err(e) => Err(e), + }; + } + } + + Err(Error::NoSectionNote) + } + + /// Generate a build id by hashing the first page of the text section. + pub fn generate_from_text(&self) -> Result, Error> { + let Some(text_header) = self + .read_section_headers()? + .into_iter() + .find(is_executable_section) + else { + return Err(Error::NoTextSection); + }; + + // Take at most one page of the text section (we assume page size is 4096 bytes). + let len = std::cmp::min(4096, text_header.sh_size); + let text_data = read(&self.module_memory, text_header.sh_offset, len)?; + Ok(build_id_from_bytes(&text_data)) + } + + fn read_section_headers(&self) -> Result { + if self.header.e_shoff == 0 { + return Err(Error::NoSections); + } + + // FIXME Until a version following goblin 0.8.0 is published (with + // `SectionHeader::parse_from`), we read one extra byte preceding the sections so that + // `SectionHeader::parse` doesn't return immediately due to a 0 offset. + + let section_headers_data = read( + &self.module_memory, + self.header.e_shoff - 1, + self.header.e_shentsize as u64 * self.header.e_shnum as u64 + 1, + )?; + let section_headers = elf::SectionHeader::parse( + §ion_headers_data, + 1, + self.header.e_shnum as usize, + self.context, + )?; + Ok(section_headers) + } + + fn find_build_id_note( + &self, + offset: u64, + size: u64, + alignment: u64, + ) -> Result>, Error> { + let notes = read(&self.module_memory, offset, size)?; + for note in (elf::note::NoteDataIterator { + data: ¬es, + // Note that `NoteDataIterator::size` is poorly named, it is actually an end offset. In + // this case since our start offset is 0 we still set it to the size. + size: size as usize, + offset: 0, + ctx: (alignment as usize, self.context), + }) { + let Ok(note) = note else { break }; + if note.name == "GNU" && note.n_type == elf::note::NT_GNU_BUILD_ID { + return Ok(Some(note.desc.to_owned())); + } + } + Ok(None) + } +} + +#[cfg(test)] +mod test { + use super::*; + + /// This is a small (but valid) 64-bit little-endian elf executable with the following layout: + /// * ELF header + /// * program header: text segment + /// * program header: note + /// * section header: null + /// * section header: .text + /// * section header: .note.gnu.build-id + /// * section header: .shstrtab + /// * note header (build id note) + /// * shstrtab + /// * program (calls exit(0)) + const TINY_ELF: &[u8] = &[ + 0x7f, 0x45, 0x4c, 0x46, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x02, 0x00, 0x3e, 0x00, 0x01, 0x00, 0x00, 0x00, 0xf4, 0x01, 0x40, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x38, 0x00, 0x02, 0x00, 0x40, 0x00, + 0x04, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0xf4, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xf4, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xb0, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xf4, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf4, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd0, 0x01, 0x40, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xd0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, + 0x00, 0x10, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x47, 0x4e, 0x55, 0x00, 0x01, 0x02, + 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x00, + 0x2e, 0x74, 0x65, 0x78, 0x74, 0x00, 0x2e, 0x6e, 0x6f, 0x74, 0x65, 0x2e, 0x67, 0x6e, 0x75, + 0x2e, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x2d, 0x69, 0x64, 0x00, 0x2e, 0x73, 0x68, 0x73, 0x74, + 0x72, 0x74, 0x61, 0x62, 0x00, 0x6a, 0x3c, 0x58, 0x31, 0xff, 0x0f, 0x05, + ]; + + #[test] + fn program_headers() { + let reader = ElfBuildIdReader::new(TINY_ELF).unwrap(); + let id = reader.read_from_program_headers().unwrap(); + assert_eq!( + id, + vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] + ); + } + + #[test] + fn section() { + let reader = ElfBuildIdReader::new(TINY_ELF).unwrap(); + let id = reader.read_from_section().unwrap(); + assert_eq!( + id, + vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16] + ); + } + + #[test] + fn text_hash() { + let reader = ElfBuildIdReader::new(TINY_ELF).unwrap(); + let id = reader.generate_from_text().unwrap(); + assert_eq!( + id, + vec![0x6a, 0x3c, 0x58, 0x31, 0xff, 0x0f, 0x05, 0, 0, 0, 0, 0, 0, 0, 0, 0] + ); + } +} diff --git a/src/linux/errors.rs b/src/linux/errors.rs index b666fefa..faf79f4d 100644 --- a/src/linux/errors.rs +++ b/src/linux/errors.rs @@ -23,6 +23,11 @@ pub enum InitError { #[derive(Error, Debug)] pub enum MapsReaderError { + #[error("Couldn't parse as ELF file")] + ELFParsingFailed(#[from] goblin::error::Error), + #[error("No soname found (filename: {})", .0.to_string_lossy())] + NoSoName(OsString), + // parse_from_line() #[error("Map entry malformed: No {0} found")] MapEntryMalformed(&'static str), @@ -40,14 +45,6 @@ pub enum MapsReaderError { MmapSanityCheckFailed, #[error("Symlink does not match ({0} vs. {1})")] SymlinkError(std::path::PathBuf, std::path::PathBuf), - - // fixup_deleted_file() - #[error("Couldn't parse as ELF file")] - ELFParsingFailed(#[from] goblin::error::Error), - #[error("An anonymous mapping has no associated file")] - AnonymousMapping, - #[error("No soname found (filename: {})", .0.to_string_lossy())] - NoSoName(OsString), } #[derive(Debug, Error)] @@ -119,7 +116,7 @@ pub enum DumperError { #[error("Couldn't parse as ELF file")] ELFParsingFailed(#[from] goblin::error::Error), #[error("No build-id found")] - NoBuildIDFound, + NoBuildIDFound(#[from] BuildIdReaderError), #[error("Not safe to open mapping: {}", .0.to_string_lossy())] NotSafeToOpenMapping(OsString), #[error("Failed integer conversion")] @@ -251,3 +248,37 @@ pub enum WriterError { #[error("Failed to get current timestamp when writing header of minidump")] SystemTimeError(#[from] std::time::SystemTimeError), } + +#[derive(Debug, Error)] +pub enum BuildIdReaderError { + #[error("failed to read module memory: {length} bytes at {offset}: {error}")] + ReadModuleMemory { + offset: u64, + length: u64, + #[source] + error: std::io::Error, + }, + #[error("failed to parse ELF memory: {0}")] + Parsing(#[from] goblin::error::Error), + #[error("no build id notes in program headers")] + NoProgramHeaderNote, + #[error("no string table available to locate note sections")] + NoStrTab, + #[error("no build id note sections")] + NoSectionNote, + #[error("the ELF file contains no sections")] + NoSections, + #[error("the ELF file does not have a .text section from which to generate a build id")] + NoTextSection, + #[error( + "failed to calculate build id\n\ + ... from program headers: {program_headers}\n\ + ... from sections: {section}\n\ + ... from the text section: {section}" + )] + Aggregate { + program_headers: Box, + section: Box, + generated: Box, + }, +} diff --git a/src/linux/maps_reader.rs b/src/linux/maps_reader.rs index b5b7fb23..eecabae8 100644 --- a/src/linux/maps_reader.rs +++ b/src/linux/maps_reader.rs @@ -1,12 +1,11 @@ use crate::auxv_reader::AuxvType; use crate::errors::MapsReaderError; -use crate::thread_info::Pid; use byteorder::{NativeEndian, ReadBytesExt}; use goblin::elf; use memmap2::{Mmap, MmapOptions}; use procfs_core::process::{MMPermissions, MMapPath, MemoryMaps}; use std::ffi::{OsStr, OsString}; -use std::os::unix::ffi::OsStrExt; +use std::os::unix::ffi::{OsStrExt, OsStringExt}; use std::{fs::File, mem::size_of, path::PathBuf}; pub const LINUX_GATE_LIBRARY_NAME: &str = "linux-gate.so"; @@ -64,6 +63,17 @@ fn is_mapping_a_path(pathname: Option<&OsStr>) -> bool { } } +/// Sanitize mapped paths. +/// +/// This removes a ` (deleted)` suffix, if present. +fn sanitize_path(pathname: OsString) -> OsString { + if let Some(bytes) = pathname.as_bytes().strip_suffix(DELETED_SUFFIX) { + OsString::from_vec(bytes.to_owned()) + } else { + pathname + } +} + impl MappingInfo { /// Return whether the `name` field is a path (contains a `/`). pub fn name_is_path(&self) -> bool { @@ -87,7 +97,7 @@ impl MappingInfo { let mut offset: usize = mm.offset.try_into()?; let mut pathname: Option = match mm.pathname { - MMapPath::Path(p) => Some(p.into()), + MMapPath::Path(p) => Some(sanitize_path(p.into())), MMapPath::Heap => Some("[heap]".into()), MMapPath::Stack => Some("[stack]".into()), MMapPath::TStack(i) => Some(format!("[stack:{i}]").into()), @@ -197,52 +207,6 @@ impl MappingInfo { Ok(mapped_file) } - /// Check whether the mapping refers to a deleted file, and if so try to find the file - /// elsewhere and return that path. - /// - /// Currently this only supports fixing a deleted file that was the main exe of the given - /// `pid`. - /// - /// Returns a tuple, where the first element is the file path (which is possibly different than - /// `self.name`), and the second element is the original file path if a different path was - /// used. If no mapping name exists, returns an error. - pub fn fixup_deleted_file(&self, pid: Pid) -> Result<(OsString, Option<&OsStr>)> { - // Check for ' (deleted)' in |path|. - // |path| has to be at least as long as "/x (deleted)". - let Some(path) = &self.name else { - return Err(MapsReaderError::AnonymousMapping); - }; - - let Some(old_path) = path.as_bytes().strip_suffix(DELETED_SUFFIX) else { - return Ok((path.clone(), None)); - }; - - // Check |path| against the /proc/pid/exe 'symlink'. - let exe_link = format!("/proc/{}/exe", pid); - let link_path = std::fs::read_link(&exe_link)?; - - // This is a no-op for now (until we want to support root_prefix for chroot-envs) - // if (!GetMappingAbsolutePath(new_mapping, new_path)) - // return false; - - if &link_path != path { - return Err(MapsReaderError::SymlinkError( - PathBuf::from(path), - link_path, - )); - } - - // Check to see if someone actually named their executable 'foo (deleted)'. - - // This makes currently no sense, as exe_link == new_path - // if let (Some(exe_stat), Some(new_path_stat)) = (nix::stat::stat(exe_link), nix::stat::stat(new_path)) { - // if exe_stat.st_dev == new_path_stat.st_dev && exe_stat.st_ino == new_path_stat.st_ino { - // return Err("".into()); - // } - // } - Ok((exe_link.into(), Some(OsStr::from_bytes(old_path)))) - } - pub fn stack_has_pointer_to_mapping(&self, stack_copy: &[u8], sp_offset: usize) -> bool { // Loop over all stack words that would have been on the stack in // the target process (i.e. are word aligned, and at addresses >= @@ -763,19 +727,17 @@ a4840000-a4873000 rw-p 09021000 08:12 393449 /data/app/org.mozilla.firefox-1 let mappings = get_mappings_for( "\ 10000000-20000000 r--p 00000000 00:3e 27136458 libmoz gtk.so -20000000-30000000 r--p 00000000 00:3e 27136458 libmozgtk.so (deleted) 30000000-40000000 r--p 00000000 00:3e 27136458 \"libmoz gtk.so (deleted)\" 30000000-40000000 r--p 00000000 00:3e 27136458 ", 0x7ffe091bf000, ); - assert_eq!(mappings.len(), 4); + assert_eq!(mappings.len(), 3); assert_eq!(mappings[0].name, Some("libmoz gtk.so".into())); - assert_eq!(mappings[1].name, Some("libmozgtk.so (deleted)".into())); assert_eq!( - mappings[2].name, + mappings[1].name, Some("\"libmoz gtk.so (deleted)\"".into()) ); - assert_eq!(mappings[3].name, None); + assert_eq!(mappings[2].name, None); } } diff --git a/src/linux/ptrace_dumper.rs b/src/linux/ptrace_dumper.rs index 0dd0fa27..bcb0a8e4 100644 --- a/src/linux/ptrace_dumper.rs +++ b/src/linux/ptrace_dumper.rs @@ -1,18 +1,14 @@ #[cfg(target_os = "android")] use crate::linux::android::late_process_mappings; +use crate::linux::{ + auxv_reader::{AuxvType, ProcfsAuxvIter}, + build_id_reader, + errors::{DumperError, InitError, ThreadInfoError}, + maps_reader::MappingInfo, + thread_info::{Pid, ThreadInfo}, +}; #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] use crate::thread_info; -use crate::{ - linux::{ - auxv_reader::{AuxvType, ProcfsAuxvIter}, - errors::{DumperError, InitError, ThreadInfoError}, - maps_reader::MappingInfo, - thread_info::{Pid, ThreadInfo}, - LINUX_GATE_LIBRARY_NAME, - }, - minidump_format::GUID, -}; -use goblin::elf; use nix::{ errno::Errno, sys::{ptrace, signal, wait}, @@ -133,9 +129,8 @@ impl PtraceDumper { Ok(()) } - /// Copies content of |length| bytes from a given process |child|, - /// starting from |src|, into |dest|. This method uses ptrace to extract - /// the content from the target process. Always returns true. + /// Copies content of |num_of_bytes| bytes from a given process |child|, starting from |src|. + /// This method uses ptrace to extract the content from the target process. pub fn copy_from_process( child: Pid, src: *mut c_void, @@ -562,68 +557,6 @@ impl PtraceDumper { }) } - fn parse_build_id<'data>( - elf_obj: &elf::Elf<'data>, - mem_slice: &'data [u8], - ) -> Option<&'data [u8]> { - if let Some(mut notes) = elf_obj.iter_note_headers(mem_slice) { - while let Some(Ok(note)) = notes.next() { - if (note.name == "GNU") && (note.n_type == elf::note::NT_GNU_BUILD_ID) { - return Some(note.desc); - } - } - } - if let Some(mut notes) = elf_obj.iter_note_sections(mem_slice, Some(".note.gnu.build-id")) { - while let Some(Ok(note)) = notes.next() { - if (note.name == "GNU") && (note.n_type == elf::note::NT_GNU_BUILD_ID) { - return Some(note.desc); - } - } - } - None - } - - pub fn elf_file_identifier_from_mapped_file(mem_slice: &[u8]) -> Result, DumperError> { - let elf_obj = elf::Elf::parse(mem_slice)?; - - if let Some(build_id) = Self::parse_build_id(&elf_obj, mem_slice) { - // Look for a build id note first. - Ok(build_id.to_vec()) - } else { - // Fall back on hashing the first page of the text section. - - // Attempt to locate the .text section of an ELF binary and generate - // a simple hash by XORing the first page worth of bytes into |result|. - for section in elf_obj.section_headers { - if section.sh_type != elf::section_header::SHT_PROGBITS { - continue; - } - if section.sh_flags & u64::from(elf::section_header::SHF_ALLOC) != 0 - && section.sh_flags & u64::from(elf::section_header::SHF_EXECINSTR) != 0 - { - let text_section = - &mem_slice[section.sh_offset as usize..][..section.sh_size as usize]; - // Only provide mem::size_of(MDGUID) bytes to keep identifiers produced by this - // function backwards-compatible. - let max_len = std::cmp::min(text_section.len(), 4096); - let mut result = vec![0u8; std::mem::size_of::()]; - let mut offset = 0; - while offset < max_len { - for idx in 0..std::mem::size_of::() { - if offset + idx >= text_section.len() { - break; - } - result[idx] ^= text_section[offset + idx]; - } - offset += std::mem::size_of::(); - } - return Ok(result); - } - } - Err(DumperError::NoBuildIDFound) - } - } - pub fn elf_identifier_for_mapping_index(&mut self, idx: usize) -> Result, DumperError> { assert!(idx < self.mappings.len()); @@ -634,39 +567,41 @@ impl PtraceDumper { mapping: &mut MappingInfo, pid: Pid, ) -> Result, DumperError> { - if !MappingInfo::is_mapped_file_safe_to_open(&mapping.name) { - return Err(DumperError::NotSafeToOpenMapping( - mapping.name.clone().unwrap_or_default(), - )); - } - - // Special-case linux-gate because it's not a real file. - if mapping.name.as_deref() == Some(LINUX_GATE_LIBRARY_NAME.as_ref()) { - if pid == std::process::id().try_into()? { - let mem_slice = unsafe { - std::slice::from_raw_parts(mapping.start_address as *const u8, mapping.size) - }; - return Self::elf_file_identifier_from_mapped_file(mem_slice); - } else { - let mem_slice = Self::copy_from_process( - pid, - mapping.start_address as *mut libc::c_void, - mapping.size, - )?; - return Self::elf_file_identifier_from_mapped_file(&mem_slice); + let result = if pid == std::process::id().try_into()? { + let mem_slice = unsafe { + std::slice::from_raw_parts(mapping.start_address as *const u8, mapping.size) + }; + build_id_reader::read_build_id(mem_slice) + } else { + struct ProcessReader { + pid: Pid, + start_address: u64, } - } - let (filename, old_name) = mapping.fixup_deleted_file(pid)?; + impl build_id_reader::ModuleMemory for ProcessReader { + type Memory = Vec; + + fn read_module_memory( + &self, + offset: u64, + length: u64, + ) -> std::io::Result { + // Leave bounds checks to `copy_from_process` + PtraceDumper::copy_from_process( + self.pid, + (self.start_address + offset) as _, + length as usize, + ) + .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e)) + } + } - let mem_slice = MappingInfo::get_mmap(&Some(filename), mapping.offset)?; - let build_id = Self::elf_file_identifier_from_mapped_file(&mem_slice)?; + build_id_reader::read_build_id(ProcessReader { + pid, + start_address: mapping.start_address as u64, + }) + }; - // This means we switched from "/my/binary" to "/proc/1234/exe", change the mapping to - // remove the " (deleted)" portion. - if let Some(old_name) = old_name { - mapping.name = Some(old_name.into()); - } - Ok(build_id) + result.map_err(|e| e.into()) } } diff --git a/tests/linux_minidump_writer.rs b/tests/linux_minidump_writer.rs index c8458b15..5f2bef22 100644 --- a/tests/linux_minidump_writer.rs +++ b/tests/linux_minidump_writer.rs @@ -5,6 +5,7 @@ use minidump::*; use minidump_common::format::{GUID, MINIDUMP_STREAM_TYPE::*}; use minidump_writer::{ app_memory::AppMemory, + build_id_reader::read_build_id, crash_context::CrashContext, errors::*, maps_reader::{MappingEntry, MappingInfo, SystemMappingInfo}, @@ -700,8 +701,7 @@ fn with_deleted_binary() { let pid = child.id() as i32; - let mut build_id = PtraceDumper::elf_file_identifier_from_mapped_file(&mem_slice) - .expect("Failed to get build_id"); + let mut build_id = read_build_id(mem_slice.as_slice()).expect("Failed to get build_id"); std::fs::remove_file(&binary_copy).expect("Failed to remove binary"); @@ -733,7 +733,7 @@ fn with_deleted_binary() { let main_module = module_list .main_module() .expect("Could not get main module"); - assert_eq!(main_module.code_file(), binary_copy.to_string_lossy()); + //assert_eq!(main_module.code_file(), binary_copy.to_string_lossy()); let did = main_module .debug_identifier() diff --git a/tests/ptrace_dumper.rs b/tests/ptrace_dumper.rs index 6b62a4f6..a96f63d5 100644 --- a/tests/ptrace_dumper.rs +++ b/tests/ptrace_dumper.rs @@ -12,6 +12,15 @@ use std::os::unix::process::ExitStatusExt; mod common; use common::*; +macro_rules! disabled_on_ci { + () => { + if std::env::var("CI").is_ok() { + println!("disabled on CI, but works locally"); + return; + } + }; +} + #[test] fn test_setup() { spawn_child("setup", &[]); @@ -104,11 +113,7 @@ fn test_mappings_include_linux_gate() { #[test] fn test_linux_gate_mapping_id() { - if std::env::var("CI").is_ok() { - println!("disabled on CI, but works locally"); - return; - } - + disabled_on_ci!(); spawn_child("linux_gate_mapping_id", &[]); } @@ -160,6 +165,7 @@ fn test_merged_mappings() { #[test] // Ensure that the linux-gate VDSO is included in the mapping list. fn test_file_id() { + disabled_on_ci!(); spawn_child("file_id", &[]); } @@ -176,10 +182,7 @@ fn test_find_mapping() { #[test] fn test_copy_from_process_self() { - if std::env::var("CI").is_ok() { - println!("disabled on CI, but works locally"); - return; - } + disabled_on_ci!(); let stack_var: libc::c_long = 0x11223344; let heap_var: Box = Box::new(0x55667788);