1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <elf_parser.h>
17 #include "utilities.h"
18
19 using namespace OHOS::Developtools::HiPerf::ELF;
20 namespace OHOS {
21 namespace Developtools {
22 namespace HiPerf {
ElfFile(const std::string & filename)23 ElfFile::ElfFile(const std::string &filename)
24 {
25 #if is_mingw
26 std::string resolvedPath = CanonicalizeSpecPath(filename.c_str());
27 fd_ = open(resolvedPath.c_str(), O_RDONLY | O_BINARY);
28 #else
29 std::string resolvedPath = CanonicalizeSpecPath(filename.c_str());
30 fd_ = open(resolvedPath.c_str(), O_RDONLY);
31 #endif
32 if (fd_ != -1) {
33 struct stat sb;
34 if (fstat(fd_, &sb) == -1) {
35 HLOGE("unable to check the file size");
36 } else {
37 HLOGD("file stat size %" PRIu64 "", sb.st_size);
38
39 mmap_ = mmap(0, sb.st_size, PROT_READ, MAP_PRIVATE, fd_, 0);
40 if (mmap_ == MMAP_FAILED) {
41 HLOGE("unable to map the file size %" PRIu64 " ", sb.st_size);
42 mmapSize_ = 0;
43 } else {
44 mmapSize_ = sb.st_size;
45 HLOGD("mmap build with size %" PRIu64 " ", mmapSize_);
46 }
47 }
48 }
49 }
50
~ElfFile()51 ElfFile::~ElfFile()
52 {
53 if (mmap_ != MMAP_FAILED) {
54 munmap(mmap_, mmapSize_);
55 }
56
57 if (fd_ != -1) {
58 close(fd_);
59 fd_ = -1;
60 }
61 }
62
MakeUnique(const std::string & filename)63 std::unique_ptr<ElfFile> ElfFile::MakeUnique(const std::string &filename)
64 {
65 std::unique_ptr<ElfFile> file {new (std::nothrow) ElfFile(filename)};
66 if (file == nullptr) {
67 HLOGE("Error in ElfFile::MakeUnique(): ElfFile::ElfFile() failed");
68 return nullptr;
69 }
70 if (!file->IsOpened()) {
71 HLOGE("Error in ElfFile::MakeUnique(): elf file not opended");
72 return nullptr;
73 }
74 if (!file->ParseFile()) {
75 HLOGE("parse elf file failed");
76 return nullptr;
77 }
78 return file;
79 }
80
ParseFile()81 bool ElfFile::ParseFile()
82 {
83 if (!ParseElfHeader()) {
84 HLOGE("Error in ElfFile::MakeUnique(): ElfFile::ParseElfHeader() failed");
85 return false;
86 }
87 if (!ParsePrgHeaders()) {
88 HLOGE("Error in ElfFile::MakeUnique(): ElfFile::ParsePrgHeaders() failed");
89 return false;
90 }
91 if (!ParseSecNamesStr()) {
92 HLOGE("Error in ElfFile::MakeUnique(): ElfFile::ParseSecNamesStr() failed");
93 return false;
94 }
95 if (!ParseSecHeaders()) {
96 HLOGE("Error in ElfFile::MakeUnique(): ElfFile::ParseSecHeaders() failed");
97 return false;
98 }
99 return true;
100 }
101
ParseElfHeader()102 bool ElfFile::ParseElfHeader()
103 {
104 ssize_t ret = lseek(fd_, 0, SEEK_SET);
105 if (ret != 0) {
106 HLOGW("lseek ret %zu", ret);
107 return false;
108 }
109 HLOG_ASSERT(ret == 0);
110 unsigned char ehdrBuf[ehdr64Size] {0};
111 size_t readsize = ReadFile(ehdrBuf, ehdr64Size);
112 if (readsize < ehdr64Size) {
113 HLOGW("file size not enough, try read %zu, only have %zu", ehdr64Size, readsize);
114 }
115 HLOG_ASSERT(readsize > 0);
116 ehdr_ = ElfHeader::MakeUnique(ehdrBuf, readsize);
117 return !(ehdr_ == nullptr);
118 }
119
ParsePrgHeaders()120 bool ElfFile::ParsePrgHeaders()
121 {
122 size_t phdrSize = ehdr_->phdrEntSize_;
123 size_t numPhdrs = ehdr_->phdrNumEnts_;
124 uint64_t phdrOffset = ehdr_->phdrOffset_;
125 int64_t ret = lseek(fd_, phdrOffset, SEEK_SET);
126 HLOG_ASSERT(ret == static_cast<int64_t>(phdrOffset));
127 char *phdrsBuf = new (std::nothrow) char[phdrSize * numPhdrs];
128 if (phdrsBuf == nullptr) {
129 HLOGE("Error in ELF::ElfFile::ParsePrgHeaders(): new failed");
130 return false;
131 }
132 (void)memset_s(phdrsBuf, phdrSize * numPhdrs, 0, phdrSize * numPhdrs);
133 ret = ReadFile(phdrsBuf, phdrSize * numPhdrs);
134 if (ret != static_cast<int64_t>(phdrSize * numPhdrs)) {
135 delete[] phdrsBuf;
136 phdrsBuf = nullptr;
137 return false;
138 }
139 char *phdrBuf = phdrsBuf;
140 for (size_t count = 0; count < numPhdrs; ++count) {
141 std::unique_ptr<ProgramHeader> phdr = ProgramHeader::MakeUnique(phdrBuf, phdrSize);
142 if (phdr == nullptr) {
143 delete[] phdrsBuf;
144 phdrsBuf = nullptr;
145 HLOGE("Error in Elf::ParsePrgHeaders(): ProgramHeader::MakeUnique() failed");
146 return false;
147 }
148 phdrs_.push_back(std::move(phdr));
149 phdrBuf += phdrSize;
150 }
151 delete[] phdrsBuf;
152 phdrsBuf = nullptr;
153 return true;
154 }
155
ParseSecNamesStr()156 bool ElfFile::ParseSecNamesStr()
157 {
158 // get string table section header
159 size_t shdrSize = ehdr_->shdrEntSize_;
160 size_t shdrIndex = ehdr_->shdrStrTabIdx_;
161 uint64_t shdrOffset = ehdr_->shdrOffset_ + ((uint64_t)shdrIndex) * shdrSize;
162 int64_t ret = lseek(fd_, shdrOffset, SEEK_SET);
163 HLOG_ASSERT(ret == static_cast<int64_t>(shdrOffset));
164 char *shdrBuf = new (std::nothrow) char[shdrSize];
165 if (shdrBuf == nullptr) {
166 HLOGE("Error in ElfFile::ParseSecNamesStr(): new failed");
167 return false;
168 }
169 (void)memset_s(shdrBuf, shdrSize, 0, shdrSize);
170 ret = ReadFile(shdrBuf, shdrSize);
171 HLOG_ASSERT(ret == static_cast<int64_t>(shdrSize));
172 const std::string secName {".shstrtab"};
173 shdrs_[secName] = SectionHeader::MakeUnique(shdrBuf, shdrSize, shdrIndex);
174 if (shdrs_[secName] == nullptr) {
175 HLOGE("Error in ElfFile::ParseSecNamesStr(): SectionHeader::MakeUnique() failed");
176 delete[] shdrBuf;
177 shdrBuf = nullptr;
178 return false;
179 }
180 delete[] shdrBuf;
181 shdrBuf = nullptr;
182
183 // get content of string section table
184 uint64_t secOffset = shdrs_[secName]->fileOffset_;
185 size_t secSize = shdrs_[secName]->secSize_;
186 ret = lseek(fd_, secOffset, SEEK_SET);
187 HLOG_ASSERT(ret == static_cast<int64_t>(secOffset));
188 char *secNamesBuf = new (std::nothrow) char[secSize];
189 if (secNamesBuf == nullptr) {
190 HLOGE("Error in ElfFile::ParseSecNamesStr(): new secNamesBuf failed");
191 return false;
192 }
193 (void)memset_s(secNamesBuf, secSize, '\0', secSize);
194 ret = ReadFile(secNamesBuf, secSize);
195 if (ret != static_cast<int64_t>(secSize)) {
196 delete[] secNamesBuf;
197 secNamesBuf = nullptr;
198 return false;
199 }
200 secNamesStr_ = std::string(secNamesBuf, secNamesBuf + secSize);
201 delete[] secNamesBuf;
202 secNamesBuf = nullptr;
203 return true;
204 }
205
ParseSecHeaders()206 bool ElfFile::ParseSecHeaders()
207 {
208 size_t shdrSize = ehdr_->shdrEntSize_;
209 size_t numShdrs = ehdr_->shdrNumEnts_;
210 uint64_t shdrOffset = ehdr_->shdrOffset_;
211 int64_t ret = lseek(fd_, shdrOffset, SEEK_SET);
212 HLOG_ASSERT(ret == static_cast<int64_t>(shdrOffset));
213 char *shdrsBuf = new (std::nothrow) char[shdrSize * numShdrs];
214 if (shdrsBuf == nullptr) {
215 HLOGE("Error in ELF::ElfFile::ParseSecHeaders(): new failed");
216 return false;
217 }
218 (void)memset_s(shdrsBuf, shdrSize * numShdrs, '\0', shdrSize * numShdrs);
219 ret = ReadFile(shdrsBuf, shdrSize * numShdrs);
220 HLOG_ASSERT(ret == static_cast<int64_t>(shdrSize * numShdrs));
221 char *shdrBuf = shdrsBuf;
222 for (size_t count = 0; count < numShdrs; ++count) {
223 if (count == ehdr_->shdrStrTabIdx_) {
224 shdrBuf += shdrSize;
225 continue;
226 }
227 std::unique_ptr<SectionHeader> shdr = SectionHeader::MakeUnique(shdrBuf, shdrSize, count);
228 if (shdr == nullptr) {
229 delete[] shdrsBuf;
230 shdrsBuf = nullptr;
231 return false;
232 }
233 std::string secName = GetSectionName(shdr->nameIndex_);
234 shdrs_[secName] = std::move(shdr);
235 shdr.reset(nullptr);
236 shdrBuf += shdrSize;
237 }
238 delete[] shdrsBuf;
239 shdrsBuf = nullptr;
240 return true;
241 }
242
ParseSymTable(const std::string secName)243 bool ElfFile::ParseSymTable(const std::string secName)
244 {
245 if (shdrs_.find(secName) == shdrs_.end()) {
246 HLOGE("Error in ELF::ElfFile::ParseSymTable(): section %s does not exist", secName.c_str());
247 return false;
248 } else {
249 return ParseSymTable(shdrs_[secName].get());
250 }
251 }
252
ParseSymTable(const SectionHeader * shdr)253 bool ElfFile::ParseSymTable(const SectionHeader *shdr)
254 {
255 if (shdr == nullptr) {
256 return false;
257 }
258 uint64_t secOffset = shdr->fileOffset_;
259 int64_t ret = lseek(fd_, secOffset, SEEK_SET);
260 HLOG_ASSERT(ret == static_cast<int64_t>(secOffset));
261 uint64_t secSize = shdr->secSize_;
262 uint64_t entrySize = shdr->secEntrySize_;
263 char *secBuf = new (std::nothrow) char[secSize];
264 if (secBuf == nullptr) {
265 HLOGE("Error in EFL::ElfFile::ParseSymTable(): new failed");
266 return false;
267 }
268 ret = ReadFile(secBuf, secSize);
269 HLOG_ASSERT(ret == static_cast<int64_t>(secSize));
270 symTable_ = SymbolTable::MakeUnique(symNamesStr_, secBuf, secSize, entrySize);
271 if (symTable_ == nullptr) {
272 delete[] secBuf;
273 secBuf = nullptr;
274 return false;
275 }
276 delete[] secBuf;
277 secBuf = nullptr;
278 return true;
279 }
280
ParseSymNamesStr()281 bool ElfFile::ParseSymNamesStr()
282 {
283 const std::string secName {".strtab"};
284 if (shdrs_.find(secName) == shdrs_.end()) {
285 HLOGE("Error in ElfFile::ParseSymNamesStr(): section %s does not exist", secName.c_str());
286 return false;
287 }
288 const auto &shdr = shdrs_[secName];
289 uint64_t secOffset = shdr->fileOffset_;
290 uint64_t secSize = shdr->secSize_;
291 int64_t ret = lseek(fd_, secOffset, SEEK_SET);
292 char *secBuf = new (std::nothrow) char[secSize];
293 if (secBuf == nullptr) {
294 HLOGE("Error in ElfFile::ParsesymNamesStr(): new failed");
295 return false;
296 }
297 (void)memset_s(secBuf, secSize, '\0', secSize);
298 ret = ReadFile(secBuf, secSize);
299 HLOG_ASSERT(ret == static_cast<int64_t>(secSize));
300 symNamesStr_ = std::string(secBuf, secSize);
301 if (symNamesStr_ == "") {
302 delete[] secBuf;
303 secBuf = nullptr;
304 return false;
305 }
306 delete[] secBuf;
307 secBuf = nullptr;
308 return true;
309 }
310
ParseDynSymTable()311 bool ElfFile::ParseDynSymTable()
312 {
313 const std::string secName {".dynsym"};
314 if (shdrs_.find(secName) == shdrs_.end()) {
315 HLOGE("Error in ELF::ElfFile::ParseSymTable(): section %s does not exist", secName.c_str());
316 return false;
317 }
318 const auto &shdr = shdrs_[secName];
319 uint64_t secOffset = shdr->fileOffset_;
320 int64_t ret = lseek(fd_, secOffset, SEEK_SET);
321 HLOG_ASSERT(ret == static_cast<int64_t>(secOffset));
322 uint64_t secSize = shdr->secSize_;
323 uint64_t entrySize = shdr->secEntrySize_;
324 char *secBuf = new (std::nothrow) char[secSize];
325 if (secBuf == nullptr) {
326 HLOGE("Error in EFL::ElfFile::ParseDynSymTable(): new failed");
327 return false;
328 }
329 ret = ReadFile(secBuf, secSize);
330 HLOG_ASSERT(ret == static_cast<int64_t>(secSize));
331 dynSymTable_ = SymbolTable::MakeUnique(symNamesStr_, secBuf, secSize, entrySize);
332 if (dynSymTable_ == nullptr) {
333 delete[] secBuf;
334 secBuf = nullptr;
335 return false;
336 }
337 delete[] secBuf;
338 secBuf = nullptr;
339 return true;
340 }
341
GetSectionName(const uint32_t startIndex)342 std::string ElfFile::GetSectionName(const uint32_t startIndex)
343 {
344 if (startIndex >= secNamesStr_.size()) {
345 HLOGF("out_of_range %s ,endIndex %d ", secNamesStr_.c_str(), startIndex);
346 return "";
347 }
348 size_t endIndex {startIndex};
349 for (; endIndex < secNamesStr_.size(); ++endIndex) {
350 if (secNamesStr_[endIndex] == '\0') {
351 break;
352 }
353 }
354 return secNamesStr_.substr(startIndex, endIndex - startIndex);
355 }
356 } // namespace HiPerf
357 } // namespace Developtools
358 } // namespace OHOS