fixup! Support .gnu_debugdata section

Author: d-e-s-o

CHANGELOG.md

@@ -2,6 +2,8 @@ Unreleased
 ----------
 - Added support for `/usr/lib/debug/.build-id` debug link target
   directory
+- Added support for compressed `.gnu_debugdata` ELF sections
+  (MiniDebugInfo)
 
 
 0.2.2
@@ -11,7 +13,6 @@ Unreleased
   provided by the user
 - Fixed backtrace reporting on contextualized errors
 - Added bindings for Go language
-- Added support for .gnu_debugdata
 
 
 0.2.1

Cargo.toml

@@ -88,7 +88,6 @@ default = [
   "demangle",
   "dwarf",
   "zlib",
-  "xz2",
 ]
 # Enable this feature to enable APK support (mostly relevant for
 # Android).
@@ -119,8 +118,9 @@ zlib = ["dep:miniz_oxide"]
 # currently only used for handling compressed debug information.
 zstd = ["dep:zstd"]
 # Enable this feature to enable support for xz decompression. This is
-# currently only used for handling .gnu_debugdata section (MiniDebugInfo)
-xz2 = ["dep:xz2"]
+# currently only used for handling `.gnu_debugdata` section data
+# (MiniDebugInfo)
+xz = ["dep:xz2"]
 
 # Below here are dev-mostly features that should not be needed by
 # regular users.

data/gnu_debugdata.sh

@@ -1,40 +1,42 @@
-# taken from the original MiniDebugInfo documentation found here:
+# Taken from the original MiniDebugInfo documentation found here:
 # https://www.sourceware.org/gdb/current/onlinedocs/gdb.html/MiniDebugInfo.html
 
+# Create temporary directory
+tmpdir=$(mktemp -d)
+cleanup() { rm -rf "$tmpdir"; }
+trap cleanup EXIT
+
 # Extract the dynamic symbols from the main binary, there is no need
 # to also have these in the normal symbol table.
-nm -D $1 --format=posix --defined-only \
-  | awk '{ print $1 }' | sort > dynsyms
+nm --dynamic "$1" --format=posix --defined-only \
+  | awk '{ print $1 }' | sort > "$tmpdir/dynsyms"
 
 # Extract all the text (i.e. function) symbols from the debuginfo.
 # (Note that we actually also accept "D" symbols, for the benefit
 # of platforms like PowerPC64 that use function descriptors.)
-nm $1 --format=posix --defined-only \
+nm "$1" --format=posix --defined-only \
   | awk '{ if ($2 == "T" || $2 == "t" || $2 == "D") print $1 }' \
-  | sort > funcsyms
+  | sort > "$tmpdir/funcsyms"
 
 # Keep all the function symbols not already in the dynamic symbol
 # table.
-comm -13 dynsyms funcsyms > keep_symbols
+comm -13 "$tmpdir/dynsyms" "$tmpdir/funcsyms" > "$tmpdir/keep_symbols"
 
 # Separate full debug info into debug binary.
-objcopy --only-keep-debug $1 debug
+objcopy --only-keep-debug "$1" "$tmpdir/debug"
 
 # Copy the full debuginfo, keeping only a minimal set of symbols and
 # removing some unnecessary sections.
-objcopy -S --remove-section .gdb_index --remove-section .comment \
-  --keep-symbols=keep_symbols debug mini_debuginfo
-
-# cp src to dst and operate on that
-cp $1 $2
+objcopy --strip-all --remove-section .gdb_index --remove-section .comment \
+  --keep-symbols="$tmpdir/keep_symbols" "$tmpdir/debug" "$tmpdir/mini_debuginfo"
 
-# Drop the full debug info from the original binary.
-strip --strip-all -R .comment $2
+# Copy src to dst and operate on that.
+cp "$1" "$2"
 
-# Inject the compressed data into the .gnu_debugdata section of the
-# original binary.
-xz mini_debuginfo
-objcopy --add-section .gnu_debugdata=mini_debuginfo.xz $2
+# Drop the full debug info from the target binary.
+strip --strip-all --remove-section .comment "$2"
 
-# Clean up temporary files.
-rm dynsyms funcsyms keep_symbols debug mini_debuginfo.xz
+# Inject the compressed data into the `.gnu_debugdata` section of the
+# target binary.
+xz "$tmpdir/mini_debuginfo"
+objcopy --add-section .gnu_debugdata="$tmpdir/mini_debuginfo.xz" "$2"

dev/Cargo.toml

@@ -48,7 +48,7 @@ libbpf-sys = {version = "1.6", default-features = false, optional = true}
 # TODO: Enable `zstd` feature once toolchain support for it is more
 #       widespread (enabled by default in `ld`). Remove conditionals in
 #       test code alongside.
-blazesym = {path = "../", features = ["apk", "breakpad", "gsym", "tracing", "test"]}
+blazesym = {path = "../", features = ["apk", "breakpad", "gsym", "tracing", "test", "xz"]}
 libc = "0.2"
 
 [target.'cfg(target_os = "linux")'.dependencies]

dev/build.rs

@@ -273,16 +273,17 @@ fn strip(src: &Path, dst: impl AsRef<OsStr>, options: &[&str]) {
     toolize_o("strip", src, dst, options)
 }
 
-/// move symbols from .symtab into `.gnu_debugdata`
+/// Create a file with compressed `.gnu_debugdata` data based on a
+/// source binary.
 fn gnu_debugdata(src: &Path, dst: impl AsRef<OsStr>) {
     let dst = src.with_file_name(dst);
     let convert_sh = data_dir().join("gnu_debugdata.sh");
     println!("cargo:rerun-if-changed={}", src.display());
     println!("cargo:rerun-if-changed={}", dst.display());
-    println!("cargo:rerun-if-env-changed={}", convert_sh.display());
+    println!("cargo:rerun-if-changed={}", convert_sh.display());
 
     let () = run("/bin/sh", [&convert_sh, src, &dst], identity)
-        .expect("failed to convert to .gnu_debugdata");
+        .expect("failed to create mini debuginfo file");
 
     let () = adjust_mtime(&dst).unwrap();
 }
@@ -663,7 +664,6 @@ fn prepare_test_files() {
             &["-gstrict-dwarf", "-gdwarf-5", "-gz=zstd"],
         );
     }
-    gnu_debugdata(&data_dir.join("test-no-debug.bin"), "test-debugdata.bin");
 
     // Generate this binary by passing the source file name without a
     // path to the compiler (which means we need to `cd` into the
@@ -755,6 +755,7 @@ fn prepare_test_files() {
             &format!("--add-gnu-debuglink={}", dbg.display()),
         ],
     );
+    gnu_debugdata(&src, "test-stable-addrs-debugdata.bin");
 
     let elf = data_dir.join("test-stable-addrs-no-dwarf.bin");
     objcopy(

src/elf/parser.rs

@@ -7,6 +7,7 @@ use std::fmt::Formatter;
 use std::fmt::Result as FmtResult;
 use std::fs::File;
 use std::io;
+#[cfg(feature = "xz")]
 use std::io::Read as _;
 use std::io::Seek as _;
 use std::io::SeekFrom;
@@ -272,7 +273,7 @@ fn decompress_zstd(_data: &[u8]) -> Result<Vec<u8>> {
     ))
 }
 
-#[cfg(feature = "xz2")]
+#[cfg(feature = "xz")]
 fn decompress_xz(data: &[u8]) -> Result<Vec<u8>> {
     use xz2::read::XzDecoder;
 
@@ -285,7 +286,7 @@ fn decompress_xz(data: &[u8]) -> Result<Vec<u8>> {
     Ok(decompressed)
 }
 
-#[cfg(not(feature = "xz2"))]
+#[cfg(not(feature = "xz"))]
 fn decompress_xz(_data: &[u8]) -> Result<Vec<u8>> {
     Err(Error::with_unsupported(
         "ELF section is xz compressed but xz compression support is not enabled",
@@ -458,8 +459,6 @@ struct Cache<'elf, B> {
     dynsym: OnceCell<SymbolTableCache<'elf>>,
     /// The section data.
     section_data: OnceCell<Box<[OnceCell<Cow<'elf, [u8]>>]>>,
-    /// Potential decompressed `.gnu_debugdata` contents.
-    debugdata: OnceCell<Cow<'elf, [u8]>>,
 }
 
 impl<'elf, B> Cache<'elf, B>
@@ -477,7 +476,6 @@ where
             symtab: OnceCell::new(),
             dynsym: OnceCell::new(),
             section_data: OnceCell::new(),
-            debugdata: OnceCell::new(),
         }
     }
 
@@ -832,58 +830,35 @@ where
         Ok(syms)
     }
 
-    #[cfg(feature = "xz2")]
-    fn parse_debugdata(&self) -> Result<Option<Vec<u8>>> {
-        let idx = if let Some(idx) = self.find_section(".gnu_debugdata")? {
-            idx
+    fn parse_debugdata(&self) -> Result<Vec<u8>> {
+        if let Some(idx) = self.find_section(".gnu_debugdata")? {
+            // NB: We assume here that `.gnu_debugdata` will never be
+            //     of type `SHT_NOBITS`, which just logically doesn't
+            //     make sense to be used.
+            self.section_data_raw(idx)
+                .and_then(|data| decompress_xz(&data))
         } else {
-            // The symbol table does not exists. Fake an empty one.
-            return Ok(None)
-        };
-
-        let shdr = self.section_hdr(idx)?;
-        if shdr.type_() == SHT_NOBITS {
-            return Ok(None)
+            Ok(Vec::new())
         }
-
-        let sh_size = shdr.size();
-        let sh_offset = shdr.offset();
-
-        let data = self
-            .backend
-            .read_pod_slice::<u8>(sh_offset, sh_size as usize)
-            .context("failed to read .gnu_debugdata section data")?;
-
-        let decompressed = decompress_xz(&data)?;
-
-        Ok(Some(decompressed))
-    }
-
-    #[cfg(not(feature = "xz2"))]
-    fn parse_debugdata(&self) -> Result<Option<Vec<u8>>> {
-        // We don't have the means to decompress it, fake an empty one.
-        return Ok(None)
     }
 
     fn ensure_symtab_cache(&self) -> Result<&SymbolTableCache<'elf>> {
-        self.symtab.get_or_try_init_(|| {
+        self.symtab.get_or_try_init_(move || {
             let mut syms = self.parse_syms(".symtab")?;
             let mut strtab = self.parse_strs(".strtab")?;
+
             if syms.is_empty() {
-                let data = self.debugdata.get_or_try_init_(|| {
-                    if let Some(data) = self.parse_debugdata()? {
-                        Result::<_, Error>::Ok(Cow::Owned(data))
-                    } else {
-                        Ok(Cow::Borrowed([].as_slice()))
-                    }
-                })?;
+                let data = self.parse_debugdata()?;
                 if !data.is_empty() {
-                    // to allow self-referentiality here, we have to artificially
-                    // extend the lifetime of `data` to `'elf`
-                    let data_slice = unsafe { mem::transmute::<&[u8], &'elf [u8]>(data) };
-                    let cache = Cache::new(data_slice);
-                    syms = cache.parse_syms(".symtab")?;
-                    strtab = cache.parse_strs(".strtab")?;
+                    let cache = Cache::new(data.as_slice());
+                    // Because we don't store the decompressed data
+                    // anywhere (and we don't want to to avoid
+                    // self-referentiality), convert the parsed data
+                    // into their owned counterparts.
+                    syms = cache.parse_syms(".symtab")?.to_owned();
+                    strtab = cache
+                        .parse_strs(".strtab")
+                        .map(|strs| Cow::Owned(strs.to_vec()))?;
                 }
             }
             let cache = SymbolTableCache::new(syms, strtab);
@@ -2127,7 +2102,6 @@ mod tests {
             symtab: OnceCell::new(),
             dynsym: OnceCell::new(),
             section_data: OnceCell::new(),
-            debugdata: OnceCell::new(),
         };
 
         assert_eq!(cache.find_section(".symtab").unwrap(), Some(2));
@@ -2234,29 +2208,12 @@ mod tests {
             symtab: OnceCell::new(),
             dynsym: OnceCell::new(),
             section_data: OnceCell::from(vec![OnceCell::new(), OnceCell::new()].into_boxed_slice()),
-            debugdata: OnceCell::new(),
         };
 
         let new_data = cache.section_data(1).unwrap();
         assert_eq!(new_data, data);
     }
 
-    /// Make sure that we can look up a symbol residing in `.gnu_debugdata`.
-    #[cfg(feature = "xz2")]
-    #[test]
-    fn lookup_from_gnu_debugdata() {
-        let bin_name = Path::new(&env!("CARGO_MANIFEST_DIR"))
-            .join("data")
-            .join("test-debugdata.bin");
-
-        let parser = ElfParser::open(bin_name.as_path()).unwrap();
-        let opts = FindAddrOpts::default();
-        let addr = parser.find_addr("fibonacci", &opts).unwrap();
-        assert_eq!(addr.len(), 1);
-        let sym = &addr[0];
-        assert_eq!(sym.name, "fibonacci");
-    }
-
     /// Benchmark creation of our "str2symtab" table.
     ///
     /// Creating this table exercises a lot of the parser code paths and

src/elf/types.rs

@@ -115,6 +115,13 @@ where
             ),
         }
     }
+
+    pub fn to_owned(&self) -> ElfNSlice<'static, T> {
+        match self {
+            Self::B32(slice) => ElfNSlice::B32(Cow::Owned(slice.to_vec())),
+            Self::B64(slice) => ElfNSlice::B64(Cow::Owned(slice.to_vec())),
+        }
+    }
 }
 
 

tests/suite/symbolize.rs

@@ -463,6 +463,26 @@ fn symbolize_elf_stripped() {
     assert_eq!(result, Symbolized::Unknown(Reason::MissingSyms));
 }
 
+/// Make sure that we can symbolize data from a compressed
+/// `.gnu_debugdata` section.
+#[tag(other_os)]
+#[test]
+fn symbolize_elf_compressed_gnu_debugdata() {
+    let path = Path::new(&env!("CARGO_MANIFEST_DIR"))
+        .join("data")
+        .join("test-stable-addrs-debugdata.bin");
+    let src = Source::Elf(Elf::new(path));
+    let symbolizer = Symbolizer::new();
+    let result = symbolizer
+        .symbolize_single(&src, Input::VirtOffset(0x2000200))
+        .unwrap()
+        .into_sym()
+        .unwrap();
+
+    assert_eq!(result.name, "factorial");
+    assert_eq!(result.addr, 0x2000200);
+}
+
 /// Check that we can symbolize data in a non-existent ELF binary after
 /// caching it.
 #[test]