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(new MapInfo(nullptr, 0x1000, 0x20000, 0, PROT_READ | PROT_WRITE, tf_->path));
54 }
55
56 void MultipleThreadTest(std::string expected_build_id);
57
58 MemoryFake* memory_;
59 ElfFake* elf_;
60 ElfInterfaceFake* elf_interface_;
61 std::unique_ptr<ElfFake> elf_container_;
62 std::unique_ptr<MapInfo> map_info_;
63 std::unique_ptr<TemporaryFile> tf_;
64 };
65
TEST_F(MapInfoGetBuildIDTest,no_elf_and_no_valid_elf_in_memory)66 TEST_F(MapInfoGetBuildIDTest, no_elf_and_no_valid_elf_in_memory) {
67 MapInfo info(nullptr, 0x1000, 0x2000, 0, PROT_READ, "");
68
69 EXPECT_EQ("", info.GetBuildID());
70 EXPECT_EQ("", info.GetPrintableBuildID());
71 }
72
TEST_F(MapInfoGetBuildIDTest,from_elf)73 TEST_F(MapInfoGetBuildIDTest, from_elf) {
74 map_info_->elf.reset(elf_container_.release());
75 elf_interface_->FakeSetBuildID("FAKE_BUILD_ID");
76
77 EXPECT_EQ("FAKE_BUILD_ID", map_info_->GetBuildID());
78 EXPECT_EQ("46414b455f4255494c445f4944", map_info_->GetPrintableBuildID());
79 }
80
TEST_F(MapInfoGetBuildIDTest,from_elf_no_sign_extension)81 TEST_F(MapInfoGetBuildIDTest, from_elf_no_sign_extension) {
82 map_info_->elf.reset(elf_container_.release());
83
84 std::string build_id = {static_cast<char>(0xfa), static_cast<char>(0xab), static_cast<char>(0x12),
85 static_cast<char>(0x02)};
86 elf_interface_->FakeSetBuildID(build_id);
87
88 EXPECT_EQ("\xFA\xAB\x12\x2", map_info_->GetBuildID());
89 EXPECT_EQ("faab1202", map_info_->GetPrintableBuildID());
90 }
91
MultipleThreadTest(std::string expected_build_id)92 void MapInfoGetBuildIDTest::MultipleThreadTest(std::string expected_build_id) {
93 static constexpr size_t kNumConcurrentThreads = 100;
94
95 std::string build_id_values[kNumConcurrentThreads];
96 std::vector<std::thread*> threads;
97
98 std::atomic_bool wait;
99 wait = true;
100 // Create all of the threads and have them do the GetLoadBias at the same time
101 // to make it likely that a race will occur.
102 for (size_t i = 0; i < kNumConcurrentThreads; i++) {
103 std::thread* thread = new std::thread([i, this, &wait, &build_id_values]() {
104 while (wait)
105 ;
106 build_id_values[i] = map_info_->GetBuildID();
107 });
108 threads.push_back(thread);
109 }
110
111 // Set them all going and wait for the threads to finish.
112 wait = false;
113 for (auto thread : threads) {
114 thread->join();
115 delete thread;
116 }
117
118 // Now verify that all of the elf files are exactly the same and valid.
119 for (size_t i = 0; i < kNumConcurrentThreads; i++) {
120 EXPECT_EQ(expected_build_id, build_id_values[i]) << "Thread " << i << " mismatched.";
121 }
122 }
123
TEST_F(MapInfoGetBuildIDTest,multiple_thread_elf_exists)124 TEST_F(MapInfoGetBuildIDTest, multiple_thread_elf_exists) {
125 map_info_->elf.reset(elf_container_.release());
126 elf_interface_->FakeSetBuildID("FAKE_BUILD_ID");
127
128 MultipleThreadTest("FAKE_BUILD_ID");
129 }
130
InitElfData(int fd)131 static void InitElfData(int fd) {
132 Elf32_Ehdr ehdr;
133 TestInitEhdr(&ehdr, ELFCLASS32, EM_ARM);
134 ehdr.e_shoff = 0x2000;
135 ehdr.e_shnum = 3;
136 ehdr.e_shentsize = sizeof(Elf32_Shdr);
137 ehdr.e_shstrndx = 2;
138 off_t offset = 0;
139 ASSERT_EQ(offset, lseek(fd, offset, SEEK_SET));
140 ASSERT_EQ(static_cast<ssize_t>(sizeof(ehdr)), write(fd, &ehdr, sizeof(ehdr)));
141
142 char note_section[128];
143 Elf32_Nhdr note_header = {};
144 note_header.n_namesz = 4; // "GNU"
145 note_header.n_descsz = 12; // "ELF_BUILDID"
146 note_header.n_type = NT_GNU_BUILD_ID;
147 memcpy(¬e_section, ¬e_header, sizeof(note_header));
148 size_t note_offset = sizeof(note_header);
149 memcpy(¬e_section[note_offset], "GNU", sizeof("GNU"));
150 note_offset += sizeof("GNU");
151 memcpy(¬e_section[note_offset], "ELF_BUILDID", sizeof("ELF_BUILDID"));
152 note_offset += sizeof("ELF_BUILDID");
153
154 Elf32_Shdr shdr = {};
155 shdr.sh_type = SHT_NOTE;
156 shdr.sh_name = 0x500;
157 shdr.sh_offset = 0xb000;
158 shdr.sh_size = sizeof(note_section);
159 offset += ehdr.e_shoff + sizeof(shdr);
160 ASSERT_EQ(offset, lseek(fd, offset, SEEK_SET));
161 ASSERT_EQ(static_cast<ssize_t>(sizeof(shdr)), write(fd, &shdr, sizeof(shdr)));
162
163 // The string data for section header names.
164 memset(&shdr, 0, sizeof(shdr));
165 shdr.sh_type = SHT_STRTAB;
166 shdr.sh_name = 0x20000;
167 shdr.sh_offset = 0xf000;
168 shdr.sh_size = 0x1000;
169 offset += sizeof(shdr);
170 ASSERT_EQ(offset, lseek(fd, offset, SEEK_SET));
171 ASSERT_EQ(static_cast<ssize_t>(sizeof(shdr)), write(fd, &shdr, sizeof(shdr)));
172
173 offset = 0xf500;
174 ASSERT_EQ(offset, lseek(fd, offset, SEEK_SET));
175 ASSERT_EQ(static_cast<ssize_t>(sizeof(".note.gnu.build-id")),
176 write(fd, ".note.gnu.build-id", sizeof(".note.gnu.build-id")));
177
178 offset = 0xb000;
179 ASSERT_EQ(offset, lseek(fd, offset, SEEK_SET));
180 ASSERT_EQ(static_cast<ssize_t>(sizeof(note_section)),
181 write(fd, note_section, sizeof(note_section)));
182 }
183
TEST_F(MapInfoGetBuildIDTest,from_memory)184 TEST_F(MapInfoGetBuildIDTest, from_memory) {
185 InitElfData(tf_->fd);
186
187 EXPECT_EQ("ELF_BUILDID", map_info_->GetBuildID());
188 EXPECT_EQ("454c465f4255494c444944", map_info_->GetPrintableBuildID());
189 }
190
TEST_F(MapInfoGetBuildIDTest,multiple_thread_elf_exists_in_memory)191 TEST_F(MapInfoGetBuildIDTest, multiple_thread_elf_exists_in_memory) {
192 InitElfData(tf_->fd);
193
194 MultipleThreadTest("ELF_BUILDID");
195 }
196
197 } // namespace unwindstack
198