1 /*
2 * Copyright (C) 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <elf.h>
18 #include <string.h>
19 #include <sys/mman.h>
20 #include <unistd.h>
21
22 #include <atomic>
23 #include <memory>
24 #include <string>
25 #include <thread>
26 #include <vector>
27
28 #include <android-base/test_utils.h>
29
30 #include <gtest/gtest.h>
31
32 #include <unwindstack/Elf.h>
33 #include <unwindstack/MapInfo.h>
34 #include <unwindstack/Maps.h>
35 #include <unwindstack/Memory.h>
36
37 #include "ElfFake.h"
38 #include "ElfTestUtils.h"
39 #include "MemoryFake.h"
40
41 namespace unwindstack {
42
43 class MapInfoGetBuildIDTest : public ::testing::Test {
44 protected:
SetUp()45 void SetUp() override {
46 tf_.reset(new TemporaryFile);
47
48 memory_ = new MemoryFake;
49 elf_ = new ElfFake(new MemoryFake);
50 elf_interface_ = new ElfInterfaceFake(memory_);
51 elf_->FakeSetInterface(elf_interface_);
52 elf_container_.reset(elf_);
53 map_info_.reset(
54 new MapInfo(nullptr, nullptr, 0x1000, 0x20000, 0, PROT_READ | PROT_WRITE, tf_->path));
55 }
56
57 void MultipleThreadTest(std::string expected_build_id);
58
59 MemoryFake* memory_;
60 ElfFake* elf_;
61 ElfInterfaceFake* elf_interface_;
62 std::unique_ptr<ElfFake> elf_container_;
63 std::unique_ptr<MapInfo> map_info_;
64 std::unique_ptr<TemporaryFile> tf_;
65 };
66
TEST_F(MapInfoGetBuildIDTest,no_elf_and_no_valid_elf_in_memory)67 TEST_F(MapInfoGetBuildIDTest, no_elf_and_no_valid_elf_in_memory) {
68 MapInfo info(nullptr, nullptr, 0x1000, 0x2000, 0, PROT_READ, "");
69
70 EXPECT_EQ("", info.GetBuildID());
71 EXPECT_EQ("", info.GetPrintableBuildID());
72 }
73
TEST_F(MapInfoGetBuildIDTest,from_elf)74 TEST_F(MapInfoGetBuildIDTest, from_elf) {
75 map_info_->elf.reset(elf_container_.release());
76 elf_interface_->FakeSetBuildID("FAKE_BUILD_ID");
77
78 EXPECT_EQ("FAKE_BUILD_ID", map_info_->GetBuildID());
79 EXPECT_EQ("46414b455f4255494c445f4944", map_info_->GetPrintableBuildID());
80 }
81
TEST_F(MapInfoGetBuildIDTest,from_elf_no_sign_extension)82 TEST_F(MapInfoGetBuildIDTest, from_elf_no_sign_extension) {
83 map_info_->elf.reset(elf_container_.release());
84
85 std::string build_id = {static_cast<char>(0xfa), static_cast<char>(0xab), static_cast<char>(0x12),
86 static_cast<char>(0x02)};
87 elf_interface_->FakeSetBuildID(build_id);
88
89 EXPECT_EQ("\xFA\xAB\x12\x2", map_info_->GetBuildID());
90 EXPECT_EQ("faab1202", map_info_->GetPrintableBuildID());
91 }
92
MultipleThreadTest(std::string expected_build_id)93 void MapInfoGetBuildIDTest::MultipleThreadTest(std::string expected_build_id) {
94 static constexpr size_t kNumConcurrentThreads = 100;
95
96 std::string build_id_values[kNumConcurrentThreads];
97 std::vector<std::thread*> threads;
98
99 std::atomic_bool wait;
100 wait = true;
101 // Create all of the threads and have them do the GetLoadBias at the same time
102 // to make it likely that a race will occur.
103 for (size_t i = 0; i < kNumConcurrentThreads; i++) {
104 std::thread* thread = new std::thread([i, this, &wait, &build_id_values]() {
105 while (wait)
106 ;
107 build_id_values[i] = map_info_->GetBuildID();
108 });
109 threads.push_back(thread);
110 }
111
112 // Set them all going and wait for the threads to finish.
113 wait = false;
114 for (auto thread : threads) {
115 thread->join();
116 delete thread;
117 }
118
119 // Now verify that all of the elf files are exactly the same and valid.
120 for (size_t i = 0; i < kNumConcurrentThreads; i++) {
121 EXPECT_EQ(expected_build_id, build_id_values[i]) << "Thread " << i << " mismatched.";
122 }
123 }
124
TEST_F(MapInfoGetBuildIDTest,multiple_thread_elf_exists)125 TEST_F(MapInfoGetBuildIDTest, multiple_thread_elf_exists) {
126 map_info_->elf.reset(elf_container_.release());
127 elf_interface_->FakeSetBuildID("FAKE_BUILD_ID");
128
129 MultipleThreadTest("FAKE_BUILD_ID");
130 }
131
InitElfData(int fd)132 static void InitElfData(int fd) {
133 Elf32_Ehdr ehdr;
134 TestInitEhdr(&ehdr, ELFCLASS32, EM_ARM);
135 ehdr.e_shoff = 0x2000;
136 ehdr.e_shnum = 3;
137 ehdr.e_shentsize = sizeof(Elf32_Shdr);
138 ehdr.e_shstrndx = 2;
139 off_t offset = 0;
140 ASSERT_EQ(offset, lseek(fd, offset, SEEK_SET));
141 ASSERT_EQ(static_cast<ssize_t>(sizeof(ehdr)), write(fd, &ehdr, sizeof(ehdr)));
142
143 char note_section[128];
144 Elf32_Nhdr note_header = {};
145 note_header.n_namesz = 4; // "GNU"
146 note_header.n_descsz = 12; // "ELF_BUILDID"
147 note_header.n_type = NT_GNU_BUILD_ID;
148 memcpy(¬e_section, ¬e_header, sizeof(note_header));
149 size_t note_offset = sizeof(note_header);
150 memcpy(¬e_section[note_offset], "GNU", sizeof("GNU"));
151 note_offset += sizeof("GNU");
152 memcpy(¬e_section[note_offset], "ELF_BUILDID", sizeof("ELF_BUILDID"));
153 note_offset += sizeof("ELF_BUILDID");
154
155 Elf32_Shdr shdr = {};
156 shdr.sh_type = SHT_NOTE;
157 shdr.sh_name = 0x500;
158 shdr.sh_offset = 0xb000;
159 shdr.sh_size = sizeof(note_section);
160 offset += ehdr.e_shoff + sizeof(shdr);
161 ASSERT_EQ(offset, lseek(fd, offset, SEEK_SET));
162 ASSERT_EQ(static_cast<ssize_t>(sizeof(shdr)), write(fd, &shdr, sizeof(shdr)));
163
164 // The string data for section header names.
165 memset(&shdr, 0, sizeof(shdr));
166 shdr.sh_type = SHT_STRTAB;
167 shdr.sh_name = 0x20000;
168 shdr.sh_offset = 0xf000;
169 shdr.sh_size = 0x1000;
170 offset += sizeof(shdr);
171 ASSERT_EQ(offset, lseek(fd, offset, SEEK_SET));
172 ASSERT_EQ(static_cast<ssize_t>(sizeof(shdr)), write(fd, &shdr, sizeof(shdr)));
173
174 offset = 0xf500;
175 ASSERT_EQ(offset, lseek(fd, offset, SEEK_SET));
176 ASSERT_EQ(static_cast<ssize_t>(sizeof(".note.gnu.build-id")),
177 write(fd, ".note.gnu.build-id", sizeof(".note.gnu.build-id")));
178
179 offset = 0xb000;
180 ASSERT_EQ(offset, lseek(fd, offset, SEEK_SET));
181 ASSERT_EQ(static_cast<ssize_t>(sizeof(note_section)),
182 write(fd, note_section, sizeof(note_section)));
183 }
184
TEST_F(MapInfoGetBuildIDTest,from_memory)185 TEST_F(MapInfoGetBuildIDTest, from_memory) {
186 InitElfData(tf_->fd);
187
188 EXPECT_EQ("ELF_BUILDID", map_info_->GetBuildID());
189 EXPECT_EQ("454c465f4255494c444944", map_info_->GetPrintableBuildID());
190 }
191
TEST_F(MapInfoGetBuildIDTest,multiple_thread_elf_exists_in_memory)192 TEST_F(MapInfoGetBuildIDTest, multiple_thread_elf_exists_in_memory) {
193 InitElfData(tf_->fd);
194
195 MultipleThreadTest("ELF_BUILDID");
196 }
197
198 } // namespace unwindstack
199