tequilaOS/platform_system_core
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
platform_system_core/libunwindstack/tests/ElfTest.cpp
Christopher Ferris bf373edc3c Add caching of build id in MapInfo object. 
Change the GetBuildID function to return a std::string.
Added benchmark to check how long it takes to get the build id from
a file versus an elf object.
Added a way to get an elf without passing in a valid process_memory and
added tests for this.

Test: New unit tests.
Change-Id: I3029019767e0181c758d611fe635bc1bf72d6e8e
2019-01-17 20:14:00 -08:00

534 lines
15 KiB
C++
Raw Blame History

/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <elf.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <unwindstack/Elf.h>
#include <unwindstack/MapInfo.h>
#include <unwindstack/RegsArm.h>
#include "ElfFake.h"
#include "ElfTestUtils.h"
#include "LogFake.h"
#include "MemoryFake.h"
#if !defined(PT_ARM_EXIDX)
#define PT_ARM_EXIDX 0x70000001
#endif
namespace unwindstack {
class ElfTest : public ::testing::Test {
protected:
void SetUp() override {
memory_ = new MemoryFake;
}
void InitElf32(uint32_t machine_type) {
Elf32_Ehdr ehdr;
TestInitEhdr<Elf32_Ehdr>(&ehdr, ELFCLASS32, machine_type);
ehdr.e_phoff = 0x100;
ehdr.e_ehsize = sizeof(ehdr);
ehdr.e_phentsize = sizeof(Elf32_Phdr);
ehdr.e_phnum = 1;
ehdr.e_shentsize = sizeof(Elf32_Shdr);
if (machine_type == EM_ARM) {
ehdr.e_flags = 0x5000200;
ehdr.e_phnum = 2;
}
memory_->SetMemory(0, &ehdr, sizeof(ehdr));
Elf32_Phdr phdr;
memset(&phdr, 0, sizeof(phdr));
phdr.p_type = PT_LOAD;
phdr.p_filesz = 0x10000;
phdr.p_memsz = 0x10000;
phdr.p_flags = PF_R | PF_X;
phdr.p_align = 0x1000;
memory_->SetMemory(0x100, &phdr, sizeof(phdr));
if (machine_type == EM_ARM) {
memset(&phdr, 0, sizeof(phdr));
phdr.p_type = PT_ARM_EXIDX;
phdr.p_offset = 0x30000;
phdr.p_vaddr = 0x30000;
phdr.p_paddr = 0x30000;
phdr.p_filesz = 16;
phdr.p_memsz = 16;
phdr.p_flags = PF_R;
phdr.p_align = 0x4;
memory_->SetMemory(0x100 + sizeof(phdr), &phdr, sizeof(phdr));
}
}
void InitElf64(uint32_t machine_type) {
Elf64_Ehdr ehdr;
TestInitEhdr<Elf64_Ehdr>(&ehdr, ELFCLASS64, machine_type);
ehdr.e_phoff = 0x100;
ehdr.e_flags = 0x5000200;
ehdr.e_ehsize = sizeof(ehdr);
ehdr.e_phentsize = sizeof(Elf64_Phdr);
ehdr.e_phnum = 1;
ehdr.e_shentsize = sizeof(Elf64_Shdr);
memory_->SetMemory(0, &ehdr, sizeof(ehdr));
Elf64_Phdr phdr;
memset(&phdr, 0, sizeof(phdr));
phdr.p_type = PT_LOAD;
phdr.p_filesz = 0x10000;
phdr.p_memsz = 0x10000;
phdr.p_flags = PF_R | PF_X;
phdr.p_align = 0x1000;
memory_->SetMemory(0x100, &phdr, sizeof(phdr));
}
MemoryFake* memory_;
};
TEST_F(ElfTest, invalid_memory) {
Elf elf(memory_);
ASSERT_FALSE(elf.Init());
ASSERT_FALSE(elf.valid());
}
TEST_F(ElfTest, elf_invalid) {
Elf elf(memory_);
InitElf32(EM_386);
// Corrupt the ELF signature.
memory_->SetData32(0, 0x7f000000);
ASSERT_FALSE(elf.Init());
ASSERT_FALSE(elf.valid());
ASSERT_TRUE(elf.interface() == nullptr);
std::string name;
ASSERT_FALSE(elf.GetSoname(&name));
uint64_t func_offset;
ASSERT_FALSE(elf.GetFunctionName(0, &name, &func_offset));
bool finished;
ASSERT_FALSE(elf.Step(0, 0, nullptr, nullptr, &finished));
}
TEST_F(ElfTest, elf32_invalid_machine) {
Elf elf(memory_);
InitElf32(EM_PPC);
ResetLogs();
ASSERT_FALSE(elf.Init());
ASSERT_EQ("", GetFakeLogBuf());
ASSERT_EQ("4 unwind 32 bit elf that is neither arm nor x86 nor mips: e_machine = 20\n\n",
GetFakeLogPrint());
}
TEST_F(ElfTest, elf64_invalid_machine) {
Elf elf(memory_);
InitElf64(EM_PPC64);
ResetLogs();
ASSERT_FALSE(elf.Init());
ASSERT_EQ("", GetFakeLogBuf());
ASSERT_EQ("4 unwind 64 bit elf that is neither aarch64 nor x86_64 nor mips64: e_machine = 21\n\n",
GetFakeLogPrint());
}
TEST_F(ElfTest, elf_arm) {
Elf elf(memory_);
InitElf32(EM_ARM);
ASSERT_TRUE(elf.Init());
ASSERT_TRUE(elf.valid());
ASSERT_EQ(static_cast<uint32_t>(EM_ARM), elf.machine_type());
ASSERT_EQ(ELFCLASS32, elf.class_type());
ASSERT_TRUE(elf.interface() != nullptr);
}
TEST_F(ElfTest, elf_mips) {
Elf elf(memory_);
InitElf32(EM_MIPS);
ASSERT_TRUE(elf.Init());
ASSERT_TRUE(elf.valid());
ASSERT_EQ(static_cast<uint32_t>(EM_MIPS), elf.machine_type());
ASSERT_EQ(ELFCLASS32, elf.class_type());
ASSERT_TRUE(elf.interface() != nullptr);
}
TEST_F(ElfTest, elf_x86) {
Elf elf(memory_);
InitElf32(EM_386);
ASSERT_TRUE(elf.Init());
ASSERT_TRUE(elf.valid());
ASSERT_EQ(static_cast<uint32_t>(EM_386), elf.machine_type());
ASSERT_EQ(ELFCLASS32, elf.class_type());
ASSERT_TRUE(elf.interface() != nullptr);
}
TEST_F(ElfTest, elf_arm64) {
Elf elf(memory_);
InitElf64(EM_AARCH64);
ASSERT_TRUE(elf.Init());
ASSERT_TRUE(elf.valid());
ASSERT_EQ(static_cast<uint32_t>(EM_AARCH64), elf.machine_type());
ASSERT_EQ(ELFCLASS64, elf.class_type());
ASSERT_TRUE(elf.interface() != nullptr);
}
TEST_F(ElfTest, elf_x86_64) {
Elf elf(memory_);
InitElf64(EM_X86_64);
ASSERT_TRUE(elf.Init());
ASSERT_TRUE(elf.valid());
ASSERT_EQ(static_cast<uint32_t>(EM_X86_64), elf.machine_type());
ASSERT_EQ(ELFCLASS64, elf.class_type());
ASSERT_TRUE(elf.interface() != nullptr);
}
TEST_F(ElfTest, elf_mips64) {
Elf elf(memory_);
InitElf64(EM_MIPS);
ASSERT_TRUE(elf.Init());
ASSERT_TRUE(elf.valid());
ASSERT_EQ(static_cast<uint32_t>(EM_MIPS), elf.machine_type());
ASSERT_EQ(ELFCLASS64, elf.class_type());
ASSERT_TRUE(elf.interface() != nullptr);
}
TEST_F(ElfTest, gnu_debugdata_init32) {
TestInitGnuDebugdata<Elf32_Ehdr, Elf32_Shdr>(ELFCLASS32, EM_ARM, true,
[&](uint64_t offset, const void* ptr, size_t size) {
memory_->SetMemory(offset, ptr, size);
});
Elf elf(memory_);
ASSERT_TRUE(elf.Init());
ASSERT_TRUE(elf.interface() != nullptr);
ASSERT_TRUE(elf.gnu_debugdata_interface() != nullptr);
EXPECT_EQ(0x1acU, elf.interface()->gnu_debugdata_offset());
EXPECT_EQ(0x8cU, elf.interface()->gnu_debugdata_size());
}
TEST_F(ElfTest, gnu_debugdata_init64) {
TestInitGnuDebugdata<Elf64_Ehdr, Elf64_Shdr>(ELFCLASS64, EM_AARCH64, true,
[&](uint64_t offset, const void* ptr, size_t size) {
memory_->SetMemory(offset, ptr, size);
});
Elf elf(memory_);
ASSERT_TRUE(elf.Init());
ASSERT_TRUE(elf.interface() != nullptr);
ASSERT_TRUE(elf.gnu_debugdata_interface() != nullptr);
EXPECT_EQ(0x200U, elf.interface()->gnu_debugdata_offset());
EXPECT_EQ(0x90U, elf.interface()->gnu_debugdata_size());
}
TEST_F(ElfTest, rel_pc) {
ElfFake elf(memory_);
ElfInterfaceFake* interface = new ElfInterfaceFake(memory_);
elf.FakeSetInterface(interface);
elf.FakeSetValid(true);
MapInfo map_info(nullptr, 0x1000, 0x2000, 0, 0, "");
ASSERT_EQ(0x101U, elf.GetRelPc(0x1101, &map_info));
elf.FakeSetValid(false);
ASSERT_EQ(0x101U, elf.GetRelPc(0x1101, &map_info));
}
TEST_F(ElfTest, step_in_signal_map) {
ElfFake elf(memory_);
RegsArm regs;
regs[13] = 0x50000;
regs[15] = 0x8000;
ElfInterfaceFake* interface = new ElfInterfaceFake(memory_);
elf.FakeSetInterface(interface);
memory_->SetData32(0x3000, 0xdf0027ad);
MemoryFake process_memory;
process_memory.SetData32(0x50000, 0);
for (size_t i = 0; i < 16; i++) {
process_memory.SetData32(0x500a0 + i * sizeof(uint32_t), i);
}
elf.FakeSetValid(true);
bool finished;
ASSERT_TRUE(elf.Step(0x3000, 0x1000, &regs, &process_memory, &finished));
EXPECT_FALSE(finished);
EXPECT_EQ(15U, regs.pc());
EXPECT_EQ(13U, regs.sp());
}
class ElfInterfaceMock : public ElfInterface {
public:
ElfInterfaceMock(Memory* memory) : ElfInterface(memory) {}
virtual ~ElfInterfaceMock() = default;
bool Init(uint64_t*) override { return false; }
void InitHeaders(uint64_t) override {}
bool GetSoname(std::string*) override { return false; }
bool GetFunctionName(uint64_t, std::string*, uint64_t*) override { return false; }
std::string GetBuildID() override { return ""; }
MOCK_METHOD4(Step, bool(uint64_t, Regs*, Memory*, bool*));
MOCK_METHOD2(GetGlobalVariable, bool(const std::string&, uint64_t*));
MOCK_METHOD1(IsValidPc, bool(uint64_t));
void MockSetDynamicOffset(uint64_t offset) { dynamic_offset_ = offset; }
void MockSetDynamicVaddr(uint64_t vaddr) { dynamic_vaddr_ = vaddr; }
void MockSetDynamicSize(uint64_t size) { dynamic_size_ = size; }
};
TEST_F(ElfTest, step_in_interface) {
ElfFake elf(memory_);
elf.FakeSetValid(true);
RegsArm regs;
ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
elf.FakeSetInterface(interface);
MemoryFake process_memory;
bool finished;
EXPECT_CALL(*interface, Step(0x1000, &regs, &process_memory, &finished))
.WillOnce(::testing::Return(true));
ASSERT_TRUE(elf.Step(0x1004, 0x1000, &regs, &process_memory, &finished));
}
TEST_F(ElfTest, get_global_invalid_elf) {
ElfFake elf(memory_);
elf.FakeSetValid(false);
std::string global("something");
uint64_t offset;
ASSERT_FALSE(elf.GetGlobalVariable(global, &offset));
}
TEST_F(ElfTest, get_global_valid_not_in_interface) {
ElfFake elf(memory_);
elf.FakeSetValid(true);
ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
elf.FakeSetInterface(interface);
uint64_t offset;
std::string global("something");
EXPECT_CALL(*interface, GetGlobalVariable(global, &offset)).WillOnce(::testing::Return(false));
ASSERT_FALSE(elf.GetGlobalVariable(global, &offset));
}
TEST_F(ElfTest, get_global_valid_below_load_bias) {
ElfFake elf(memory_);
elf.FakeSetValid(true);
elf.FakeSetLoadBias(0x1000);
ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
elf.FakeSetInterface(interface);
uint64_t offset;
std::string global("something");
EXPECT_CALL(*interface, GetGlobalVariable(global, &offset))
.WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x300), ::testing::Return(true)));
ASSERT_FALSE(elf.GetGlobalVariable(global, &offset));
}
TEST_F(ElfTest, get_global_valid_dynamic_zero_non_zero_load_bias) {
ElfFake elf(memory_);
elf.FakeSetValid(true);
elf.FakeSetLoadBias(0x100);
ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
elf.FakeSetInterface(interface);
uint64_t offset;
std::string global("something");
EXPECT_CALL(*interface, GetGlobalVariable(global, &offset))
.WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x300), ::testing::Return(true)));
ASSERT_TRUE(elf.GetGlobalVariable(global, &offset));
EXPECT_EQ(0x200U, offset);
}
TEST_F(ElfTest, get_global_valid_dynamic_zero) {
ElfFake elf(memory_);
elf.FakeSetValid(true);
ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
elf.FakeSetInterface(interface);
ElfInterfaceMock* gnu_interface = new ElfInterfaceMock(memory_);
elf.FakeSetGnuDebugdataInterface(gnu_interface);
uint64_t offset;
std::string global("something");
EXPECT_CALL(*interface, GetGlobalVariable(global, &offset)).WillOnce(::testing::Return(false));
EXPECT_CALL(*gnu_interface, GetGlobalVariable(global, &offset))
.WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x500), ::testing::Return(true)));
ASSERT_TRUE(elf.GetGlobalVariable(global, &offset));
EXPECT_EQ(0x500U, offset);
}
TEST_F(ElfTest, get_global_valid_in_gnu_debugdata_dynamic_zero) {
ElfFake elf(memory_);
elf.FakeSetValid(true);
ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
elf.FakeSetInterface(interface);
uint64_t offset;
std::string global("something");
EXPECT_CALL(*interface, GetGlobalVariable(global, &offset))
.WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x300), ::testing::Return(true)));
ASSERT_TRUE(elf.GetGlobalVariable(global, &offset));
EXPECT_EQ(0x300U, offset);
}
TEST_F(ElfTest, get_global_valid_dynamic_adjust_negative) {
ElfFake elf(memory_);
elf.FakeSetValid(true);
ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
interface->MockSetDynamicOffset(0x400);
interface->MockSetDynamicVaddr(0x800);
interface->MockSetDynamicSize(0x100);
elf.FakeSetInterface(interface);
uint64_t offset;
std::string global("something");
EXPECT_CALL(*interface, GetGlobalVariable(global, &offset))
.WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x850), ::testing::Return(true)));
ASSERT_TRUE(elf.GetGlobalVariable(global, &offset));
EXPECT_EQ(0x450U, offset);
}
TEST_F(ElfTest, get_global_valid_dynamic_adjust_positive) {
ElfFake elf(memory_);
elf.FakeSetValid(true);
ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
interface->MockSetDynamicOffset(0x1000);
interface->MockSetDynamicVaddr(0x800);
interface->MockSetDynamicSize(0x100);
elf.FakeSetInterface(interface);
uint64_t offset;
std::string global("something");
EXPECT_CALL(*interface, GetGlobalVariable(global, &offset))
.WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x850), ::testing::Return(true)));
ASSERT_TRUE(elf.GetGlobalVariable(global, &offset));
EXPECT_EQ(0x1050U, offset);
}
TEST_F(ElfTest, is_valid_pc_elf_invalid) {
ElfFake elf(memory_);
elf.FakeSetValid(false);
EXPECT_FALSE(elf.IsValidPc(0x100));
EXPECT_FALSE(elf.IsValidPc(0x200));
}
TEST_F(ElfTest, is_valid_pc_interface) {
ElfFake elf(memory_);
elf.FakeSetValid(true);
ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
elf.FakeSetInterface(interface);
EXPECT_CALL(*interface, IsValidPc(0x1500)).WillOnce(::testing::Return(true));
EXPECT_TRUE(elf.IsValidPc(0x1500));
}
TEST_F(ElfTest, is_valid_pc_from_gnu_debugdata) {
ElfFake elf(memory_);
elf.FakeSetValid(true);
ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
elf.FakeSetInterface(interface);
ElfInterfaceMock* gnu_interface = new ElfInterfaceMock(memory_);
elf.FakeSetGnuDebugdataInterface(gnu_interface);
EXPECT_CALL(*interface, IsValidPc(0x1500)).WillOnce(::testing::Return(false));
EXPECT_CALL(*gnu_interface, IsValidPc(0x1500)).WillOnce(::testing::Return(true));
EXPECT_TRUE(elf.IsValidPc(0x1500));
}
TEST_F(ElfTest, error_code_not_valid) {
ElfFake elf(memory_);
elf.FakeSetValid(false);
ErrorData error{ERROR_MEMORY_INVALID, 0x100};
elf.GetLastError(&error);
EXPECT_EQ(ERROR_MEMORY_INVALID, error.code);
EXPECT_EQ(0x100U, error.address);
}
TEST_F(ElfTest, error_code_valid) {
ElfFake elf(memory_);
elf.FakeSetValid(true);
ElfInterfaceFake* interface = new ElfInterfaceFake(memory_);
elf.FakeSetInterface(interface);
interface->FakeSetErrorCode(ERROR_MEMORY_INVALID);
interface->FakeSetErrorAddress(0x1000);
ErrorData error{ERROR_NONE, 0};
elf.GetLastError(&error);
EXPECT_EQ(ERROR_MEMORY_INVALID, error.code);
EXPECT_EQ(0x1000U, error.address);
EXPECT_EQ(ERROR_MEMORY_INVALID, elf.GetLastErrorCode());
EXPECT_EQ(0x1000U, elf.GetLastErrorAddress());
}
} // namespace unwindstack
Reference in a new issue View git blame Copy permalink