| // Copyright 2024 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| use ffx_e2e_emu::IsolatedEmulator; | |
| use ffx_symbolize::{AddressType, MappingDetails, MappingFlags, ResolveError, Symbolizer}; | |
| use log::info; | |
| use symbolize_test_utils::{Module, SymbolizationTestOutputs}; | |
| #[fuchsia::test(logging_minimum_severity = "TRACE")] | |
| async fn symbolize_fn_ptr() { | |
| logging_rust_cpp_bridge::init(); | |
| info!("starting emulator..."); | |
| let emu = IsolatedEmulator::start("test-ffx-symbolize-lib").await.unwrap(); | |
| info!("running print_fn_ptr component..."); | |
| let outputs = run_print_fn_ptr(&emu).await; | |
| info!("creating symbolizer instance..."); | |
| let mut symbolizer = Symbolizer::with_context(emu.env_context()).unwrap(); | |
| symbolize_and_validate_result(&outputs, &mut symbolizer); | |
| symbolizer.reset(); | |
| let invalid_location_one = symbolizer.resolve_addr(outputs.fn_one_addr, AddressType::Exact); | |
| assert!(invalid_location_one.is_err()); | |
| symbolizer.reset(); | |
| symbolize_and_validate_result(&outputs, &mut symbolizer); | |
| } | |
| fn symbolize_and_validate_result(outputs: &SymbolizationTestOutputs, symbolizer: &mut Symbolizer) { | |
| info!("adding modules to symbolizer..."); | |
| for Module { name, build_id, mappings } in &outputs.modules { | |
| let id = symbolizer.add_module(&name, &build_id); | |
| for mapping in mappings { | |
| let mut flags = MappingFlags::empty(); | |
| if mapping.readable { | |
| flags |= MappingFlags::READ; | |
| } | |
| if mapping.writeable { | |
| flags |= MappingFlags::WRITE; | |
| } | |
| if mapping.executable { | |
| flags |= MappingFlags::EXECUTE; | |
| } | |
| symbolizer | |
| .add_mapping( | |
| id, | |
| MappingDetails { | |
| start_addr: mapping.start_addr, | |
| size: mapping.size, | |
| vaddr: mapping.vaddr, | |
| flags, | |
| }, | |
| ) | |
| .unwrap(); | |
| } | |
| } | |
| info!("resolving addresses..."); | |
| let symbol_one = symbolizer.resolve_addr(outputs.fn_one_addr, AddressType::Exact).unwrap(); | |
| assert_eq!(symbol_one.len(), 1); | |
| let location_one = &symbol_one[0]; | |
| assert_eq!(location_one.function, "print_fn_ptr_bin::to_be_symbolized_one()"); | |
| assert_eq!( | |
| location_one.file_and_line.as_ref().unwrap().0, | |
| "../../src/developer/ffx/lib/symbolize/tests/print_fn_ptr.rs" | |
| ); | |
| assert!( | |
| outputs.fn_one_source_line - 2 <= location_one.file_and_line.as_ref().unwrap().1 | |
| || location_one.file_and_line.as_ref().unwrap().1 <= outputs.fn_one_source_line + 2 | |
| ); | |
| assert_eq!(location_one.library, None); | |
| // Verify AddressType::Return and AddressType::Exact behavior on fn_one: | |
| // fn_one_addr is (entry_point + 1). | |
| // Resolving fn_one_addr with Return subtracts 1, giving entry_point, which | |
| // resolves to fn_one: | |
| let symbol_one_ret = symbolizer.resolve_addr(outputs.fn_one_addr, AddressType::Return).unwrap(); | |
| assert_eq!(symbol_one_ret[0].function, "print_fn_ptr_bin::to_be_symbolized_one()"); | |
| // Resolving entry_point directly (fn_one_addr - 1) with Exact preserves the | |
| // address and resolves to fn_one: | |
| let fn_one_entry = outputs.fn_one_addr - 1; | |
| let symbol_one_entry_exact = symbolizer.resolve_addr(fn_one_entry, AddressType::Exact).unwrap(); | |
| assert_eq!(symbol_one_entry_exact[0].function, "print_fn_ptr_bin::to_be_symbolized_one()"); | |
| // Resolving entry_point (fn_one_addr - 1) with Return subtracts 1, leaving | |
| // the function boundaries: | |
| let symbol_one_entry_ret = symbolizer.resolve_addr(fn_one_entry, AddressType::Return); | |
| match symbol_one_entry_ret { | |
| Ok(locs) => { | |
| if !locs.is_empty() { | |
| assert_ne!(locs[0].function, "print_fn_ptr_bin::to_be_symbolized_one()"); | |
| } | |
| } | |
| Err(err) => { | |
| assert!( | |
| err == ResolveError::SymbolNotFound || err == ResolveError::NoOverlappingModule | |
| ); | |
| } | |
| } | |
| let symbol_two = symbolizer.resolve_addr(outputs.fn_two_addr, AddressType::Exact).unwrap(); | |
| assert_eq!(symbol_two.len(), 1); | |
| let location_two = &symbol_two[0]; | |
| assert_eq!(location_two.function, "print_fn_ptr_bin::to_be_symbolized_two()"); | |
| assert_eq!( | |
| location_two.file_and_line.as_ref().unwrap().0, | |
| "../../src/developer/ffx/lib/symbolize/tests/print_fn_ptr.rs" | |
| ); | |
| assert!( | |
| outputs.fn_two_source_line - 2 <= location_two.file_and_line.as_ref().unwrap().1 | |
| || location_two.file_and_line.as_ref().unwrap().1 <= outputs.fn_two_source_line + 2 | |
| ); | |
| assert_eq!(location_two.library, None); | |
| let libc_symbol = symbolizer.resolve_addr(outputs.libc_addr, AddressType::Exact).unwrap(); | |
| assert_eq!(libc_symbol.len(), 1); | |
| let libc_location = &libc_symbol[0]; | |
| assert_eq!(libc_location.function, "open(const char*, int)"); | |
| assert_eq!(libc_location.file_and_line.as_ref().unwrap().0, "../../sdk/lib/fdio/unistd.cc"); | |
| assert_eq!(libc_location.library.as_ref().unwrap(), "libfdio.so"); | |
| let symbol_sys_inc = | |
| symbolizer.resolve_addr(outputs.fn_sys_inc_addr, AddressType::Exact).unwrap(); | |
| assert_eq!(symbol_sys_inc.len(), 1); | |
| let sys_inc_location = &symbol_sys_inc[0]; | |
| assert!(sys_inc_location.function.ends_with("zx_channel_create")); | |
| assert_eq!( | |
| sys_inc_location.file_and_line.as_ref().unwrap().0, | |
| "fidling/gen/zircon/vdso/zx/zither/kernel/lib/syscalls/syscalls.inc" | |
| ); | |
| assert_eq!(sys_inc_location.library.as_ref().unwrap(), "<vDSO>"); | |
| assert_eq!( | |
| symbolizer.resolve_addr(outputs.heap_addr, AddressType::Exact).unwrap_err(), | |
| ResolveError::NoOverlappingModule | |
| ); | |
| assert_eq!( | |
| symbolizer.resolve_addr(outputs.no_symbol_addr, AddressType::Exact).unwrap_err(), | |
| ResolveError::SymbolNotFound | |
| ); | |
| } | |
| async fn run_print_fn_ptr(emu: &IsolatedEmulator) -> SymbolizationTestOutputs { | |
| let stdout = emu | |
| .ffx_output(&[ | |
| // JSON output prevents the command from printing its status messages to stdout. | |
| "--machine", | |
| "json", | |
| "component", | |
| "run", | |
| "/core/ffx-laboratory:print-fn-ptr", | |
| "fuchsia-pkg://fuchsia.com/print_fn_ptr#meta/print_fn_ptr.cm", | |
| // Ensure we get the component's stdout to the ffx command. | |
| "--connect-stdio", | |
| ]) | |
| .await | |
| .unwrap(); | |
| serde_json::from_str(&stdout).unwrap() | |
| } | |
| #[fuchsia::test(logging_minimum_severity = "TRACE")] | |
| async fn symbolize_unresolved() { | |
| logging_rust_cpp_bridge::init(); | |
| const FAKE_BUILD_ID: &[u8] = &[0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xCD, 0xEF]; | |
| const FAKE_START_ADDRESS: u64 = 0x1000000; | |
| const FAKE_SIZE: u64 = 0x123000; | |
| let env = ffx_config::test_init().unwrap(); | |
| let mut symbolizer = Symbolizer::with_context(&env.context).unwrap(); | |
| let module_id = symbolizer.add_module("foo.so", FAKE_BUILD_ID); | |
| symbolizer | |
| .add_mapping( | |
| module_id, | |
| MappingDetails { | |
| start_addr: FAKE_START_ADDRESS, | |
| size: FAKE_SIZE, | |
| vaddr: 0, | |
| flags: MappingFlags::READ | MappingFlags::EXECUTE, | |
| }, | |
| ) | |
| .unwrap(); | |
| assert_eq!( | |
| symbolizer | |
| .resolve_addr(FAKE_START_ADDRESS + FAKE_SIZE / 2, AddressType::Exact) | |
| .unwrap_err(), | |
| ResolveError::SymbolFileUnavailable | |
| ); | |
| assert_eq!( | |
| symbolizer | |
| .resolve_addr(FAKE_START_ADDRESS + FAKE_SIZE / 2, AddressType::Return) | |
| .unwrap_err(), | |
| ResolveError::SymbolFileUnavailable | |
| ); | |
| assert_eq!( | |
| symbolizer | |
| .resolve_addr(FAKE_START_ADDRESS + FAKE_SIZE / 2, AddressType::Unknown) | |
| .unwrap_err(), | |
| ResolveError::SymbolFileUnavailable | |
| ); | |
| } |