1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/debug/elf_reader.h"
#include <arpa/inet.h>
#include <elf.h>
#include <string.h>
#include "base/bits.h"
#include "base/containers/span.h"
#include "base/hash/sha1.h"
#include "base/strings/safe_sprintf.h"
#include "build/build_config.h"
// NOTE: This code may be used in crash handling code, so the implementation
// must avoid dynamic memory allocation or using data structures which rely on
// dynamic allocation.
namespace base {
namespace debug {
namespace {
#if __SIZEOF_POINTER__ == 4
using Ehdr = Elf32_Ehdr;
using Dyn = Elf32_Dyn;
using Half = Elf32_Half;
using Nhdr = Elf32_Nhdr;
using Word = Elf32_Word;
#else
using Ehdr = Elf64_Ehdr;
using Dyn = Elf64_Dyn;
using Half = Elf64_Half;
using Nhdr = Elf64_Nhdr;
using Word = Elf64_Word;
#endif
constexpr char kGnuNoteName[] = "GNU";
// Returns a pointer to the header of the ELF binary mapped into memory,
// or a null pointer if the header is invalid.
const Ehdr* GetElfHeader(const void* elf_mapped_base) {
const char* elf_base = reinterpret_cast<const char*>(elf_mapped_base);
if (strncmp(elf_base, ELFMAG, SELFMAG) != 0)
return nullptr;
const Ehdr* elf_header = reinterpret_cast<const Ehdr*>(elf_base);
return elf_header;
}
// Returns the ELF base address that should be used as a starting point to
// access other segments.
const char* GetElfBaseVirtualAddress(const void* elf_mapped_base) {
const char* elf_base = reinterpret_cast<const char*>(elf_mapped_base);
for (const Phdr& header : GetElfProgramHeaders(elf_mapped_base)) {
if (header.p_type == PT_LOAD) {
size_t load_bias = static_cast<size_t>(header.p_vaddr);
CHECK_GE(reinterpret_cast<uintptr_t>(elf_base), load_bias);
return elf_base - load_bias;
}
}
return elf_base;
}
} // namespace
span<const Phdr> GetElfProgramHeaders(const void* elf_mapped_base) {
// NOTE: Function should use async signal safe calls only.
const char* elf_base = reinterpret_cast<const char*>(elf_mapped_base);
const Ehdr* elf_header = GetElfHeader(elf_mapped_base);
if (!elf_header)
return {};
return span<const Phdr>(
reinterpret_cast<const Phdr*>(elf_base + elf_header->e_phoff),
elf_header->e_phnum);
}
size_t ReadElfBuildId(const void* elf_mapped_base,
bool uppercase,
ElfBuildIdBuffer build_id) {
// NOTE: Function should use async signal safe calls only.
const char* elf_virtual_base = GetElfBaseVirtualAddress(elf_mapped_base);
const Ehdr* elf_header = GetElfHeader(elf_mapped_base);
if (!elf_header)
return 0;
for (const Phdr& header : GetElfProgramHeaders(elf_mapped_base)) {
if (header.p_type != PT_NOTE)
continue;
// Look for a NT_GNU_BUILD_ID note with name == "GNU".
const char* current_section = elf_virtual_base + header.p_vaddr;
const char* section_end = current_section + header.p_memsz;
const Nhdr* current_note = nullptr;
bool found = false;
while (current_section < section_end) {
current_note = reinterpret_cast<const Nhdr*>(current_section);
if (current_note->n_type == NT_GNU_BUILD_ID) {
StringPiece note_name(current_section + sizeof(Nhdr),
current_note->n_namesz);
// Explicit constructor is used to include the '\0' character.
if (note_name == StringPiece(kGnuNoteName, sizeof(kGnuNoteName))) {
found = true;
break;
}
}
size_t section_size = bits::Align(current_note->n_namesz, 4) +
bits::Align(current_note->n_descsz, 4) +
sizeof(Nhdr);
if (section_size > static_cast<size_t>(section_end - current_section))
return 0;
current_section += section_size;
}
if (!found)
continue;
// Validate that the serialized build ID will fit inside |build_id|.
size_t note_size = current_note->n_descsz;
if ((note_size * 2) > kMaxBuildIdStringLength)
continue;
// Write out the build ID as a null-terminated hex string.
const uint8_t* build_id_raw =
reinterpret_cast<const uint8_t*>(current_note) + sizeof(Nhdr) +
bits::Align(current_note->n_namesz, 4);
size_t i = 0;
for (i = 0; i < current_note->n_descsz; ++i) {
strings::SafeSNPrintf(&build_id[i * 2], 3, (uppercase ? "%02X" : "%02x"),
build_id_raw[i]);
}
build_id[i * 2] = '\0';
// Return the length of the string.
return i * 2;
}
return 0;
}
Optional<StringPiece> ReadElfLibraryName(const void* elf_mapped_base) {
// NOTE: Function should use async signal safe calls only.
const char* elf_base = reinterpret_cast<const char*>(elf_mapped_base);
const Ehdr* elf_header = GetElfHeader(elf_mapped_base);
if (!elf_header)
return {};
for (const Phdr& header : GetElfProgramHeaders(elf_mapped_base)) {
if (header.p_type != PT_DYNAMIC)
continue;
// Read through the ELF dynamic sections to find the string table and
// SONAME offsets, which are used to compute the offset of the library
// name string.
const Dyn* dynamic_start =
reinterpret_cast<const Dyn*>(elf_base + header.p_vaddr);
const Dyn* dynamic_end = reinterpret_cast<const Dyn*>(
elf_base + header.p_vaddr + header.p_memsz);
Word soname_strtab_offset = 0;
const char* strtab_addr = 0;
for (const Dyn* dynamic_iter = dynamic_start; dynamic_iter < dynamic_end;
++dynamic_iter) {
if (dynamic_iter->d_tag == DT_STRTAB) {
#if defined(OS_FUCHSIA) || defined(OS_ANDROID)
// Fuchsia and Android executables are position-independent, so treat
// pointers in the ELF header as offsets into the address space instead
// of absolute addresses.
strtab_addr = (size_t)dynamic_iter->d_un.d_ptr + (const char*)elf_base;
#else
strtab_addr = (const char*)dynamic_iter->d_un.d_ptr;
#endif
} else if (dynamic_iter->d_tag == DT_SONAME) {
soname_strtab_offset = dynamic_iter->d_un.d_val;
}
}
if (soname_strtab_offset && strtab_addr)
return StringPiece(strtab_addr + soname_strtab_offset);
}
return nullopt;
}
} // namespace debug
} // namespace base
|
