Resolve debug symbols in containers

For the ELF file itself blazesym does the right thing by reading files like:

```
/proc/2367/map_files/79c8000-20aec000
```

This works great when the ELF files are in a container in a separate mount
namespace. When it comes to looking for split debug info via `debuglink`,
it tries looking in by the path in the root mount namespace, which does not
work, as the files are just not there. With this change we try checking
the process mount namespace first via `/proc/<xxx>/root`.

Signed-off-by: Ivan Babrou <[email protected]>

Author: bobrik

src/maps.rs

@@ -46,6 +46,8 @@ pub struct EntryPath {
     /// parsed. This path has been sanitized and no longer contains any
     /// `(deleted)` suffixes.
     pub symbolic_path: PathBuf,
+    /// The path to the root of the mount namespace through `/proc/<xxx>/root`.
+    pub root_path: PathBuf,
     /// The struct is non-exhaustive and open to extension.
     #[doc(hidden)]
     pub _non_exhaustive: (),
@@ -211,9 +213,11 @@ pub(crate) fn parse_path_name(
             let pid = pid.resolve();
             let maps_file =
                 PathBuf::from(format!("/proc/{pid}/map_files/{vma_start:x}-{vma_end:x}"));
+            let root_path = PathBuf::from(format!("/proc/{pid}/root"));
             Some(PathName::Path(EntryPath {
                 maps_file,
                 symbolic_path,
+                root_path,
                 _non_exhaustive: (),
             }))
         }

src/symbolize/symbolizer.rs

@@ -534,16 +534,26 @@ impl SymbolizeHandler<'_> {
     }
 
     fn handle_elf_addr(&mut self, addr: Addr, file_off: u64, entry_path: &EntryPath) -> Result<()> {
+        let debug_dirs = self
+            .symbolizer
+            .maybe_debug_dirs(self.debug_syms)
+            .map(|dirs| {
+                dirs.iter()
+                    .filter_map(|dir| Some(entry_path.root_path.join(dir.strip_prefix("/").ok()?)))
+                    .chain(dirs.iter().cloned())
+                    .collect::<Vec<_>>()
+            });
+
+
         let resolver = if self.map_files {
-            self.symbolizer.elf_cache.elf_resolver(
-                entry_path,
-                self.symbolizer.maybe_debug_dirs(self.debug_syms),
-            )
+            self.symbolizer
+                .elf_cache
+                .elf_resolver(entry_path, debug_dirs.as_deref())
         } else {
             let path = &entry_path.symbolic_path;
             self.symbolizer
                 .elf_cache
-                .elf_resolver(path, self.symbolizer.maybe_debug_dirs(self.debug_syms))
+                .elf_resolver(path, debug_dirs.as_deref())
         }?;