deps: update blazesym submodule

Update the blazesym submodule to the most recent snapshot.

Signed-off-by: Daniel Müller <deso@posteo.net>

Author: d-e-s-o

blazesym

@@ -7,8 +7,8 @@ LIBBPF_OBJ := $(abspath $(OUTPUT)/libbpf.a)
 BPFTOOL_OUTPUT ?= $(abspath $(OUTPUT)/bpftool)
 BPFTOOL ?= $(BPFTOOL_OUTPUT)/bootstrap/bpftool
 LIBBLAZESYM_SRC := $(abspath ../../blazesym/)
+LIBBLAZESYM_INC := $(abspath $(LIBBLAZESYM_SRC)/include)
 LIBBLAZESYM_OBJ := $(abspath $(OUTPUT)/libblazesym.a)
-LIBBLAZESYM_HEADER := $(abspath $(OUTPUT)/blazesym.h)
 ARCH ?= $(shell uname -m | sed 's/x86_64/x86/' \
 			 | sed 's/arm.*/arm/' \
 			 | sed 's/aarch64/arm64/' \
@@ -20,7 +20,7 @@ VMLINUX := ../../vmlinux/$(ARCH)/vmlinux.h
 # Use our own libbpf API headers and Linux UAPI headers distributed with
 # libbpf to avoid dependency on system-wide headers, which could be missing or
 # outdated
-INCLUDES := -I$(OUTPUT) -I../../libbpf/include/uapi -I$(dir $(VMLINUX))
+INCLUDES := -I$(OUTPUT) -I../../libbpf/include/uapi -I$(dir $(VMLINUX)) -I$(LIBBLAZESYM_INC)
 CFLAGS := -g -Wall
 ALL_LDFLAGS := $(LDFLAGS) $(EXTRA_LDFLAGS)
 
@@ -95,16 +95,12 @@ $(BPFTOOL): | $(BPFTOOL_OUTPUT)
 
 
 $(LIBBLAZESYM_SRC)/target/release/libblazesym.a::
-	$(Q)cd $(LIBBLAZESYM_SRC) && $(CARGO) build --features=cheader,dont-generate-test-files --release
+	$(Q)cd $(LIBBLAZESYM_SRC) && $(CARGO) build --release
 
 $(LIBBLAZESYM_OBJ): $(LIBBLAZESYM_SRC)/target/release/libblazesym.a | $(OUTPUT)
 	$(call msg,LIB, $@)
 	$(Q)cp $(LIBBLAZESYM_SRC)/target/release/libblazesym.a $@
 
-$(LIBBLAZESYM_HEADER): $(LIBBLAZESYM_SRC)/target/release/libblazesym.a | $(OUTPUT)
-	$(call msg,LIB,$@)
-	$(Q)cp $(LIBBLAZESYM_SRC)/target/release/blazesym.h $@
-
 # Build BPF code
 $(OUTPUT)/%.bpf.o: %.bpf.c $(LIBBPF_OBJ) $(wildcard %.h) $(VMLINUX) | $(OUTPUT) $(BPFTOOL)
 	$(call msg,BPF,$@)
@@ -125,7 +121,7 @@ $(OUTPUT)/%.o: %.c $(wildcard %.h) | $(OUTPUT)
 	$(call msg,CC,$@)
 	$(Q)$(CC) $(CFLAGS) $(INCLUDES) -c $(filter %.c,$^) -o $@
 
-$(patsubst %,$(OUTPUT)/%.o,$(BZS_APPS)): $(LIBBLAZESYM_HEADER)
+$(patsubst %,$(OUTPUT)/%.o,$(BZS_APPS)): $(LIBBLAZESYM_OBJ)
 
 $(BZS_APPS): $(LIBBLAZESYM_OBJ)
 

examples/c/Makefile

@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
 /* Copyright (c) 2022 Facebook */
+#include <assert.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <string.h>
@@ -30,25 +32,26 @@ static long perf_event_open(struct perf_event_attr *hw_event, pid_t pid, int cpu
 	return ret;
 }
 
-static struct blazesym *symbolizer;
+static struct blaze_symbolizer *symbolizer;
 
 static void show_stack_trace(__u64 *stack, int stack_sz, pid_t pid)
 {
-	const struct blazesym_result *result;
-	const struct blazesym_csym *sym;
-	sym_src_cfg src;
+	const struct blaze_result *result;
+	const struct blaze_sym *sym;
 	int i, j;
 
+	assert(sizeof(uintptr_t) == sizeof(uint64_t));
+
 	if (pid) {
-		src.src_type = SRC_T_PROCESS;
-		src.params.process.pid = pid;
+		struct blaze_symbolize_src_process src = {
+			.pid = pid,
+		};
+		result = blaze_symbolize_process(symbolizer, &src, (const uintptr_t *)stack, stack_sz);
 	} else {
-		src.src_type = SRC_T_KERNEL;
-		src.params.kernel.kallsyms = NULL;
-		src.params.kernel.kernel_image = NULL;
+		struct blaze_symbolize_src_kernel src = {};
+		result = blaze_symbolize_kernel(symbolizer, &src, (const uintptr_t *)stack, stack_sz);
 	}
 
-	result = blazesym_symbolize(symbolizer, &src, 1, (const uint64_t *)stack, stack_sz);
 
 	for (i = 0; i < stack_sz; i++) {
 		if (!result || result->size <= i || !result->entries[i].size) {
@@ -60,11 +63,11 @@ static void show_stack_trace(__u64 *stack, int stack_sz, pid_t pid)
 			sym = &result->entries[i].syms[0];
 			if (sym->path && sym->path[0]) {
 				printf("  %d [<%016llx>] %s+0x%llx %s:%ld\n", i, stack[i],
-				       sym->symbol, stack[i] - sym->start_address, sym->path,
-				       sym->line_no);
+				       sym->symbol, stack[i] - sym->addr, sym->path,
+				       sym->line);
 			} else {
 				printf("  %d [<%016llx>] %s+0x%llx\n", i, stack[i], sym->symbol,
-				       stack[i] - sym->start_address);
+				       stack[i] - sym->addr);
 			}
 			continue;
 		}
@@ -74,15 +77,15 @@ static void show_stack_trace(__u64 *stack, int stack_sz, pid_t pid)
 			sym = &result->entries[i].syms[j];
 			if (sym->path && sym->path[0]) {
 				printf("        %s+0x%llx %s:%ld\n", sym->symbol,
-				       stack[i] - sym->start_address, sym->path, sym->line_no);
+				       stack[i] - sym->addr, sym->path, sym->line);
 			} else {
 				printf("        %s+0x%llx\n", sym->symbol,
-				       stack[i] - sym->start_address);
+				       stack[i] - sym->addr);
 			}
 		}
 	}
 
-	blazesym_result_free(result);
+	blaze_result_free(result);
 }
 
 /* Receive events from the ring buffer. */
@@ -166,7 +169,7 @@ int main(int argc, char *const argv[])
 		goto cleanup;
 	}
 
-	symbolizer = blazesym_new();
+	symbolizer = blaze_symbolizer_new();
 	if (!symbolizer) {
 		fprintf(stderr, "Fail to create a symbolizer\n");
 		err = -1;
@@ -235,7 +238,7 @@ int main(int argc, char *const argv[])
 	}
 	ring_buffer__free(ring_buf);
 	profile_bpf__destroy(skel);
-	blazesym_free(symbolizer);
+	blaze_symbolizer_free(symbolizer);
 	free(online_mask);
 	return -err;
 }

examples/c/profile.c

@@ -7,7 +7,7 @@ license = "GPL-2.0 OR BSD-3-Clause"
 [dependencies]
 libbpf-rs = "0.19"
 nix = "0.24.1"
-blazesym = { path = "../../../blazesym", features = ["cheader", "dont-generate-test-files"] }
+blazesym = { path = "../../../blazesym", default-features = false, features = ["dont-generate-test-files"] }
 libc = "*"
 clap = { version = "3.1.18", features = ["derive"] }
 

examples/rust/Cargo.lock

@@ -19,7 +19,7 @@ mod profile;
 use profile::*;
 
 extern crate blazesym;
-use blazesym::*;
+use blazesym::symbolize;
 
 extern crate libc;
 
@@ -73,17 +73,30 @@ fn attach_perf_event(
 }
 
 // Pid 0 means a kernel space stack.
-fn show_stack_trace(stack: &[u64], symbolizer: &BlazeSymbolizer, pid: u32) {
+fn show_stack_trace(stack: &[u64], symbolizer: &symbolize::Symbolizer, pid: u32) {
+    let converted_stack;
+    // The kernel always reports `u64` addresses, whereas blazesym uses `usize`.
+    // Convert the stack trace as necessary.
+    let stack = if mem::size_of::<blazesym::Addr>() != mem::size_of::<u64>() {
+        converted_stack = stack
+            .iter()
+            .copied()
+            .map(|addr| addr as blazesym::Addr)
+            .collect::<Vec<_>>();
+        converted_stack.as_slice()
+    } else {
+        // SAFETY: `Addr` has the same size as `u64`, so it can be trivially and
+        //         safely converted.
+        unsafe { mem::transmute::<_, &[blazesym::Addr]>(stack) }
+    };
+
     let src = if pid == 0 {
-        SymbolSrcCfg::Kernel {
-            kallsyms: None,
-            kernel_image: None,
-        }
+        symbolize::Source::from(symbolize::Kernel::default())
     } else {
-        SymbolSrcCfg::Process { pid: Some(pid) }
+        symbolize::Source::from(symbolize::Process::new(pid.into()))
     };
 
-    let syms = symbolizer.symbolize(&[src], stack);
+    let syms = symbolizer.symbolize(&src, stack).unwrap();
     for i in 0..stack.len() {
         if syms.len() <= i || syms[i].len() == 0 {
             println!("  {} [<{:016x}>]", i, stack[i]);
@@ -92,23 +105,23 @@ fn show_stack_trace(stack: &[u64], symbolizer: &BlazeSymbolizer, pid: u32) {
 
         if syms[i].len() == 1 {
             let sym = &syms[i][0];
-            if !sym.path.is_empty() {
+            if !sym.path.as_os_str().is_empty() {
                 println!(
                     "  {} [<{:016x}>] {}+0x{:x} {}:{}",
                     i,
                     stack[i],
                     sym.symbol,
-                    stack[i] - sym.start_address,
-                    sym.path,
-                    sym.line_no
+                    stack[i] - sym.addr,
+                    sym.path.display(),
+                    sym.line
                 );
             } else {
                 println!(
                     "  {} [<{:016x}>] {}+0x{}",
                     i,
                     stack[i],
                     sym.symbol,
-                    stack[i] - sym.start_address
+                    stack[i] - sym.addr
                 );
             }
             continue;
@@ -117,22 +130,22 @@ fn show_stack_trace(stack: &[u64], symbolizer: &BlazeSymbolizer, pid: u32) {
         println!("  {} [<{:016x}>]", i, stack[i]);
 
         for sym in &syms[i] {
-            if !sym.path.is_empty() {
+            if !sym.path.as_os_str().is_empty() {
                 println!(
                     "        {}+0x{:x} {}:{}",
                     sym.symbol,
-                    stack[i] - sym.start_address,
-                    sym.path,
-                    sym.line_no
+                    stack[i] - sym.addr,
+                    sym.path.display(),
+                    sym.line
                 );
             } else {
-                println!("        {}+0x{}", sym.symbol, stack[i] - sym.start_address);
+                println!("        {}+0x{}", sym.symbol, stack[i] - sym.addr);
             }
         }
     }
 }
 
-fn event_handler(symbolizer: &BlazeSymbolizer, data: &[u8]) -> ::std::os::raw::c_int {
+fn event_handler(symbolizer: &symbolize::Symbolizer, data: &[u8]) -> ::std::os::raw::c_int {
     if data.len() != mem::size_of::<stacktrace_event>() {
         eprintln!(
             "Invalid size {} != {}",
@@ -190,7 +203,7 @@ fn main() -> Result<(), Error> {
     let args = Args::parse();
     let freq = if args.freq < 1 { 1 } else { args.freq };
 
-    let symbolizer = BlazeSymbolizer::new()?;
+    let symbolizer = symbolize::Symbolizer::new();
 
     let skel_builder = ProfileSkelBuilder::default();
     let open_skel = skel_builder.open().unwrap();