1 /*
2 * Copyright (C) 2017 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 <sys/mman.h>
18 #include <sys/types.h>
19 #include <unistd.h>
20
21 #include <memory>
22 #include <mutex>
23 #include <string>
24
25 #include <unwindstack/Elf.h>
26 #include <unwindstack/MapInfo.h>
27 #include <unwindstack/Maps.h>
28 #include <unwindstack/Memory.h>
29
30 namespace unwindstack {
31
GetFileMemory()32 Memory* MapInfo::GetFileMemory() {
33 std::unique_ptr<MemoryFileAtOffset> memory(new MemoryFileAtOffset);
34 if (offset == 0) {
35 if (memory->Init(name, 0)) {
36 return memory.release();
37 }
38 return nullptr;
39 }
40
41 // There are two possibilities when the offset is non-zero.
42 // - There is an elf file embedded in a file.
43 // - The whole file is an elf file, and the offset needs to be saved.
44 //
45 // Map in just the part of the file for the map. If this is not
46 // a valid elf, then reinit as if the whole file is an elf file.
47 // If the offset is a valid elf, then determine the size of the map
48 // and reinit to that size. This is needed because the dynamic linker
49 // only maps in a portion of the original elf, and never the symbol
50 // file data.
51 uint64_t map_size = end - start;
52 if (!memory->Init(name, offset, map_size)) {
53 return nullptr;
54 }
55
56 bool valid;
57 uint64_t max_size;
58 Elf::GetInfo(memory.get(), &valid, &max_size);
59 if (!valid) {
60 // Init as if the whole file is an elf.
61 if (memory->Init(name, 0)) {
62 elf_offset = offset;
63 return memory.release();
64 }
65 return nullptr;
66 }
67
68 if (max_size > map_size) {
69 if (memory->Init(name, offset, max_size)) {
70 return memory.release();
71 }
72 // Try to reinit using the default map_size.
73 if (memory->Init(name, offset, map_size)) {
74 return memory.release();
75 }
76 return nullptr;
77 }
78 return memory.release();
79 }
80
CreateMemory(const std::shared_ptr<Memory> & process_memory)81 Memory* MapInfo::CreateMemory(const std::shared_ptr<Memory>& process_memory) {
82 if (end <= start) {
83 return nullptr;
84 }
85
86 elf_offset = 0;
87
88 // Fail on device maps.
89 if (flags & MAPS_FLAGS_DEVICE_MAP) {
90 return nullptr;
91 }
92
93 // First try and use the file associated with the info.
94 if (!name.empty()) {
95 Memory* memory = GetFileMemory();
96 if (memory != nullptr) {
97 return memory;
98 }
99 }
100
101 // If the map isn't readable, don't bother trying to read from process memory.
102 if (!(flags & PROT_READ)) {
103 return nullptr;
104 }
105 return new MemoryRange(process_memory, start, end - start, 0);
106 }
107
GetElf(const std::shared_ptr<Memory> & process_memory,bool init_gnu_debugdata)108 Elf* MapInfo::GetElf(const std::shared_ptr<Memory>& process_memory, bool init_gnu_debugdata) {
109 // Make sure no other thread is trying to add the elf to this map.
110 std::lock_guard<std::mutex> guard(mutex_);
111
112 if (elf.get() != nullptr) {
113 return elf.get();
114 }
115
116 bool locked = false;
117 if (Elf::CachingEnabled() && !name.empty()) {
118 Elf::CacheLock();
119 locked = true;
120 if (Elf::CacheGet(this)) {
121 Elf::CacheUnlock();
122 return elf.get();
123 }
124 }
125
126 Memory* memory = CreateMemory(process_memory);
127 if (locked) {
128 if (Elf::CacheAfterCreateMemory(this)) {
129 delete memory;
130 Elf::CacheUnlock();
131 return elf.get();
132 }
133 }
134 elf.reset(new Elf(memory));
135 // If the init fails, keep the elf around as an invalid object so we
136 // don't try to reinit the object.
137 elf->Init(init_gnu_debugdata);
138
139 if (locked) {
140 Elf::CacheAdd(this);
141 Elf::CacheUnlock();
142 }
143 return elf.get();
144 }
145
GetLoadBias(const std::shared_ptr<Memory> & process_memory)146 uint64_t MapInfo::GetLoadBias(const std::shared_ptr<Memory>& process_memory) {
147 uint64_t cur_load_bias = load_bias.load();
148 if (cur_load_bias != static_cast<uint64_t>(-1)) {
149 return cur_load_bias;
150 }
151
152 {
153 // Make sure no other thread is trying to add the elf to this map.
154 std::lock_guard<std::mutex> guard(mutex_);
155 if (elf != nullptr) {
156 if (elf->valid()) {
157 cur_load_bias = elf->GetLoadBias();
158 load_bias = cur_load_bias;
159 return cur_load_bias;
160 } else {
161 load_bias = 0;
162 return 0;
163 }
164 }
165 }
166
167 // Call lightweight static function that will only read enough of the
168 // elf data to get the load bias.
169 std::unique_ptr<Memory> memory(CreateMemory(process_memory));
170 cur_load_bias = Elf::GetLoadBias(memory.get());
171 load_bias = cur_load_bias;
172 return cur_load_bias;
173 }
174
175 } // namespace unwindstack
176