libunwindstack/tests/ElfTest.cpp

/*
 * 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 <gtest/gtest.h>

#include "Elf.h"

#include "MemoryFake.h"

#if !defined(PT_ARM_EXIDX)
#define PT_ARM_EXIDX 0x70000001
#endif

class ElfTest : public ::testing::Test {
 protected:
  void SetUp() override {
    memory_ = new MemoryFake;
  }

  template <typename Ehdr>
  void InitEhdr(Ehdr* ehdr) {
    memset(ehdr, 0, sizeof(Ehdr));
    memcpy(&ehdr->e_ident[0], ELFMAG, SELFMAG);
    ehdr->e_ident[EI_DATA] = ELFDATA2LSB;
    ehdr->e_ident[EI_VERSION] = EV_CURRENT;
    ehdr->e_ident[EI_OSABI] = ELFOSABI_SYSV;

    ehdr->e_type = ET_DYN;
    ehdr->e_version = EV_CURRENT;
  }

  void InitElf32(uint32_t machine) {
    Elf32_Ehdr ehdr;

    InitEhdr<Elf32_Ehdr>(&ehdr);
    ehdr.e_ident[EI_CLASS] = ELFCLASS32;

    ehdr.e_machine = machine;
    ehdr.e_entry = 0;
    ehdr.e_phoff = 0x100;
    ehdr.e_shoff = 0;
    ehdr.e_flags = 0;
    ehdr.e_ehsize = sizeof(ehdr);
    ehdr.e_phentsize = sizeof(Elf32_Phdr);
    ehdr.e_phnum = 1;
    ehdr.e_shentsize = sizeof(Elf32_Shdr);
    ehdr.e_shnum = 0;
    ehdr.e_shstrndx = 0;
    if (machine == 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_offset = 0;
    phdr.p_vaddr = 0;
    phdr.p_paddr = 0;
    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 == 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) {
    Elf64_Ehdr ehdr;

    InitEhdr<Elf64_Ehdr>(&ehdr);
    ehdr.e_ident[EI_CLASS] = ELFCLASS64;

    ehdr.e_machine = machine;
    ehdr.e_entry = 0;
    ehdr.e_phoff = 0x100;
    ehdr.e_shoff = 0;
    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);
    ehdr.e_shnum = 0;
    ehdr.e_shstrndx = 0;
    memory_->SetMemory(0, &ehdr, sizeof(ehdr));

    Elf64_Phdr phdr;
    memset(&phdr, 0, sizeof(phdr));
    phdr.p_type = PT_LOAD;
    phdr.p_offset = 0;
    phdr.p_vaddr = 0;
    phdr.p_paddr = 0;
    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));
  }

  template <typename Ehdr, typename Shdr>
  void GnuDebugdataInitFail(Ehdr* ehdr);

  template <typename Ehdr, typename Shdr>
  void GnuDebugdataInit(Ehdr* ehdr);

  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));

  ASSERT_FALSE(elf.Step(0, nullptr, nullptr));
}

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_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);
}

template <typename Ehdr, typename Shdr>
void ElfTest::GnuDebugdataInitFail(Ehdr* ehdr) {
  Elf elf(memory_);

  uint64_t offset = 0x2000;

  ehdr->e_shoff = offset;
  ehdr->e_shnum = 3;
  ehdr->e_shentsize = sizeof(Shdr);
  ehdr->e_shstrndx = 2;
  memory_->SetMemory(0, ehdr, sizeof(*ehdr));

  Shdr shdr;
  memset(&shdr, 0, sizeof(shdr));
  shdr.sh_type = SHT_NULL;
  memory_->SetMemory(offset, &shdr, sizeof(shdr));
  offset += ehdr->e_shentsize;

  memset(&shdr, 0, sizeof(shdr));
  shdr.sh_type = SHT_PROGBITS;
  shdr.sh_name = 0x100;
  shdr.sh_addr = 0x5000;
  shdr.sh_offset = 0x5000;
  shdr.sh_entsize = 0x100;
  shdr.sh_size = 0x800;
  memory_->SetMemory(offset, &shdr, sizeof(shdr));
  offset += ehdr->e_shentsize;

  memset(&shdr, 0, sizeof(shdr));
  shdr.sh_type = SHT_STRTAB;
  shdr.sh_name = 0x200000;
  shdr.sh_offset = 0xf000;
  shdr.sh_size = 0x1000;
  memory_->SetMemory(offset, &shdr, sizeof(shdr));
  offset += ehdr->e_shentsize;

  memory_->SetMemory(0xf100, ".gnu_debugdata", sizeof(".gnu_debugdata"));

  ASSERT_TRUE(elf.Init());
  ASSERT_TRUE(elf.interface() != nullptr);
  ASSERT_TRUE(elf.gnu_debugdata_interface() == nullptr);
  EXPECT_EQ(0x5000U, elf.interface()->gnu_debugdata_offset());
  EXPECT_EQ(0x800U, elf.interface()->gnu_debugdata_size());

  elf.InitGnuDebugdata();
}

TEST_F(ElfTest, gnu_debugdata_init_fail32) {
  Elf32_Ehdr ehdr;
  InitEhdr<Elf32_Ehdr>(&ehdr);
  ehdr.e_ident[EI_CLASS] = ELFCLASS32;
  ehdr.e_machine = EM_ARM;

  GnuDebugdataInitFail<Elf32_Ehdr, Elf32_Shdr>(&ehdr);
}

TEST_F(ElfTest, gnu_debugdata_init_fail64) {
  Elf64_Ehdr ehdr;
  InitEhdr<Elf64_Ehdr>(&ehdr);
  ehdr.e_ident[EI_CLASS] = ELFCLASS64;
  ehdr.e_machine = EM_AARCH64;

  GnuDebugdataInitFail<Elf64_Ehdr, Elf64_Shdr>(&ehdr);
}

template <typename Ehdr, typename Shdr>
void ElfTest::GnuDebugdataInit(Ehdr* ehdr) {
  Elf elf(memory_);

  uint64_t offset = 0x2000;

  ehdr->e_shoff = offset;
  ehdr->e_shnum = 3;
  ehdr->e_shentsize = sizeof(Shdr);
  ehdr->e_shstrndx = 2;
  memory_->SetMemory(0, ehdr, sizeof(*ehdr));

  Shdr shdr;
  memset(&shdr, 0, sizeof(shdr));
  shdr.sh_type = SHT_NULL;
  memory_->SetMemory(offset, &shdr, sizeof(shdr));
  offset += ehdr->e_shentsize;

  uint64_t gnu_offset = offset;
  offset += ehdr->e_shentsize;

  memset(&shdr, 0, sizeof(shdr));
  shdr.sh_type = SHT_STRTAB;
  shdr.sh_name = 0x200000;
  shdr.sh_offset = 0xf000;
  shdr.sh_size = 0x1000;
  memory_->SetMemory(offset, &shdr, sizeof(shdr));
  offset += ehdr->e_shentsize;

  memory_->SetMemory(0xf100, ".gnu_debugdata", sizeof(".gnu_debugdata"));

  // Read in the compressed elf data and put it in our fake memory.
  std::string name("tests/");
  if (sizeof(Ehdr) == sizeof(Elf32_Ehdr)) {
    name += "elf32.xz";
  } else {
    name += "elf64.xz";
  }
  int fd = TEMP_FAILURE_RETRY(open(name.c_str(), O_RDONLY));
  ASSERT_NE(-1, fd) << "Cannot open " + name;
  // Assumes the file is less than 1024 bytes.
  std::vector<uint8_t> buf(1024);
  ssize_t bytes = TEMP_FAILURE_RETRY(read(fd, buf.data(), buf.size()));
  ASSERT_GT(bytes, 0);
  // Make sure the file isn't too big.
  ASSERT_NE(static_cast<size_t>(bytes), buf.size())
      << "File " + name + " is too big, increase buffer size.";
  close(fd);
  buf.resize(bytes);
  memory_->SetMemory(0x5000, buf);

  memset(&shdr, 0, sizeof(shdr));
  shdr.sh_type = SHT_PROGBITS;
  shdr.sh_name = 0x100;
  shdr.sh_addr = 0x5000;
  shdr.sh_offset = 0x5000;
  shdr.sh_size = bytes;
  memory_->SetMemory(gnu_offset, &shdr, sizeof(shdr));

  ASSERT_TRUE(elf.Init());
  ASSERT_TRUE(elf.interface() != nullptr);
  ASSERT_TRUE(elf.gnu_debugdata_interface() == nullptr);
  EXPECT_EQ(0x5000U, elf.interface()->gnu_debugdata_offset());

  elf.InitGnuDebugdata();
  ASSERT_TRUE(elf.gnu_debugdata_interface() != nullptr);
}

TEST_F(ElfTest, gnu_debugdata_init32) {
  Elf32_Ehdr ehdr;
  InitEhdr<Elf32_Ehdr>(&ehdr);
  ehdr.e_ident[EI_CLASS] = ELFCLASS32;
  ehdr.e_machine = EM_ARM;

  GnuDebugdataInit<Elf32_Ehdr, Elf32_Shdr>(&ehdr);
}

TEST_F(ElfTest, gnu_debugdata_init64) {
  Elf64_Ehdr ehdr;
  InitEhdr<Elf64_Ehdr>(&ehdr);
  ehdr.e_ident[EI_CLASS] = ELFCLASS64;
  ehdr.e_machine = EM_AARCH64;

  GnuDebugdataInit<Elf64_Ehdr, Elf64_Shdr>(&ehdr);
}