blob: 80e292a631e510db00dc8e2aad3555575a09e31a [file] [log] [blame]
Christopher Ferris09385e72017-04-05 13:25:04 -07001/*
2 * Copyright (C) 2016 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
Christopher Ferris60521c72017-08-18 15:10:53 -070017#include <inttypes.h>
Christopher Ferris09385e72017-04-05 13:25:04 -070018#include <sys/mman.h>
19
20#include <android-base/file.h>
Christopher Ferris60521c72017-08-18 15:10:53 -070021#include <android-base/stringprintf.h>
Christopher Ferris09385e72017-04-05 13:25:04 -070022#include <gtest/gtest.h>
23
Christopher Ferrisd226a512017-07-14 10:37:19 -070024#include <unwindstack/Maps.h>
25
26namespace unwindstack {
Christopher Ferris09385e72017-04-05 13:25:04 -070027
Christopher Ferris60521c72017-08-18 15:10:53 -070028static void VerifyLine(std::string line, MapInfo* info) {
29 BufferMaps maps(line.c_str());
30
31 if (info == nullptr) {
32 ASSERT_FALSE(maps.Parse()) << "Failed on: " + line;
33 } else {
34 ASSERT_TRUE(maps.Parse()) << "Failed on: " + line;
35 MapInfo* element = maps.Get(0);
36 ASSERT_TRUE(element != nullptr) << "Failed on: " + line;
Christopher Ferrisbe788d82017-11-27 14:50:38 -080037 info->start = element->start;
38 info->end = element->end;
39 info->offset = element->offset;
40 info->flags = element->flags;
41 info->name = element->name;
42 info->elf_offset = element->elf_offset;
Christopher Ferris60521c72017-08-18 15:10:53 -070043 }
44}
45
Christopher Ferrise7b66242017-12-15 11:17:45 -080046TEST(MapsTest, map_add) {
47 Maps maps;
48
49 maps.Add(0x1000, 0x2000, 0, PROT_READ, "fake_map", 0);
50 maps.Add(0x3000, 0x4000, 0x10, 0, "", 0x1234);
51 maps.Add(0x5000, 0x6000, 1, 2, "fake_map2", static_cast<uint64_t>(-1));
52
53 ASSERT_EQ(3U, maps.Total());
54 MapInfo* info = maps.Get(0);
55 ASSERT_EQ(0x1000U, info->start);
56 ASSERT_EQ(0x2000U, info->end);
57 ASSERT_EQ(0U, info->offset);
58 ASSERT_EQ(PROT_READ, info->flags);
59 ASSERT_EQ("fake_map", info->name);
60 ASSERT_EQ(0U, info->elf_offset);
61 ASSERT_EQ(0U, info->load_bias.load());
62}
63
Christopher Ferris60521c72017-08-18 15:10:53 -070064TEST(MapsTest, verify_parse_line) {
Christopher Ferris9d5712c2018-10-01 21:01:09 -070065 MapInfo info(nullptr);
Christopher Ferris60521c72017-08-18 15:10:53 -070066
67 VerifyLine("01-02 rwxp 03 04:05 06\n", &info);
68 EXPECT_EQ(1U, info.start);
69 EXPECT_EQ(2U, info.end);
70 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info.flags);
71 EXPECT_EQ(3U, info.offset);
72 EXPECT_EQ("", info.name);
73
74 VerifyLine("0a-0b ---s 0c 0d:0e 06 /fake/name\n", &info);
75 EXPECT_EQ(0xaU, info.start);
76 EXPECT_EQ(0xbU, info.end);
77 EXPECT_EQ(0U, info.flags);
78 EXPECT_EQ(0xcU, info.offset);
79 EXPECT_EQ("/fake/name", info.name);
80
81 VerifyLine("01-02 rwxp 03 04:05 06 /fake/name/again\n", &info);
82 EXPECT_EQ(1U, info.start);
83 EXPECT_EQ(2U, info.end);
84 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info.flags);
85 EXPECT_EQ(3U, info.offset);
86 EXPECT_EQ("/fake/name/again", info.name);
87
88 VerifyLine("-00 rwxp 00 00:00 0\n", nullptr);
89 VerifyLine("00- rwxp 00 00:00 0\n", nullptr);
90 VerifyLine("00-00 rwxp 00 :00 0\n", nullptr);
91 VerifyLine("00-00 rwxp 00 00:00 \n", nullptr);
92 VerifyLine("x-00 rwxp 00 00:00 0\n", nullptr);
93 VerifyLine("00 -00 rwxp 00 00:00 0\n", nullptr);
94 VerifyLine("00-x rwxp 00 00:00 0\n", nullptr);
95 VerifyLine("00-x rwxp 00 00:00 0\n", nullptr);
96 VerifyLine("00-00x rwxp 00 00:00 0\n", nullptr);
97 VerifyLine("00-00 rwxp0 00 00:00 0\n", nullptr);
98 VerifyLine("00-00 rwxp0 00 00:00 0\n", nullptr);
99 VerifyLine("00-00 rwp 00 00:00 0\n", nullptr);
100 VerifyLine("00-00 rwxp 0000:00 0\n", nullptr);
101 VerifyLine("00-00 rwxp 00 00 :00 0\n", nullptr);
102 VerifyLine("00-00 rwxp 00 00: 00 0\n", nullptr);
103 VerifyLine("00-00 rwxp 00 00:000\n", nullptr);
104 VerifyLine("00-00 rwxp 00 00:00 0/fake\n", nullptr);
105 VerifyLine("00-00 xxxx 00 00:00 0 /fake\n", nullptr);
106 VerifyLine("00-00 ywxp 00 00:00 0 /fake\n", nullptr);
107 VerifyLine("00-00 ryxp 00 00:00 0 /fake\n", nullptr);
108 VerifyLine("00-00 rwyp 00 00:00 0 /fake\n", nullptr);
109 VerifyLine("00-00 rwx- 00 00:00 0 /fake\n", nullptr);
110 VerifyLine("0\n", nullptr);
111 VerifyLine("00\n", nullptr);
112 VerifyLine("00-\n", nullptr);
113 VerifyLine("00-0\n", nullptr);
114 VerifyLine("00-00\n", nullptr);
115 VerifyLine("00-00 \n", nullptr);
116 VerifyLine("00-00 -\n", nullptr);
117 VerifyLine("00-00 r\n", nullptr);
118 VerifyLine("00-00 --\n", nullptr);
119 VerifyLine("00-00 rw\n", nullptr);
120 VerifyLine("00-00 ---\n", nullptr);
121 VerifyLine("00-00 rwx\n", nullptr);
122 VerifyLine("00-00 ---s\n", nullptr);
123 VerifyLine("00-00 ---p\n", nullptr);
124 VerifyLine("00-00 ---s 0\n", nullptr);
125 VerifyLine("00-00 ---p 0 \n", nullptr);
126 VerifyLine("00-00 ---p 0 0\n", nullptr);
127 VerifyLine("00-00 ---p 0 0:\n", nullptr);
128 VerifyLine("00-00 ---p 0 0:0\n", nullptr);
129 VerifyLine("00-00 ---p 0 0:0 \n", nullptr);
130
131 // Line to verify that the parser will detect a completely malformed line
132 // properly.
133 VerifyLine("7ffff7dda000-7ffff7dfd7ffff7ff3000-7ffff7ff4000 ---p 0000f000 fc:02 44171565\n",
134 nullptr);
135}
136
137TEST(MapsTest, verify_large_values) {
Christopher Ferris9d5712c2018-10-01 21:01:09 -0700138 MapInfo info(nullptr);
Christopher Ferris60521c72017-08-18 15:10:53 -0700139#if defined(__LP64__)
140 VerifyLine("fabcdef012345678-f12345678abcdef8 rwxp f0b0d0f010305070 00:00 0\n", &info);
141 EXPECT_EQ(0xfabcdef012345678UL, info.start);
142 EXPECT_EQ(0xf12345678abcdef8UL, info.end);
143 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info.flags);
144 EXPECT_EQ(0xf0b0d0f010305070UL, info.offset);
145#else
146 VerifyLine("f2345678-fabcdef8 rwxp f0305070 00:00 0\n", &info);
147 EXPECT_EQ(0xf2345678UL, info.start);
148 EXPECT_EQ(0xfabcdef8UL, info.end);
149 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info.flags);
150 EXPECT_EQ(0xf0305070UL, info.offset);
151#endif
152}
153
Christopher Ferris09385e72017-04-05 13:25:04 -0700154TEST(MapsTest, parse_permissions) {
155 BufferMaps maps(
Christopher Ferris60521c72017-08-18 15:10:53 -0700156 "1000-2000 ---s 00000000 00:00 0\n"
157 "2000-3000 r--s 00000000 00:00 0\n"
158 "3000-4000 -w-s 00000000 00:00 0\n"
159 "4000-5000 --xp 00000000 00:00 0\n"
160 "5000-6000 rwxp 00000000 00:00 0\n");
Christopher Ferris09385e72017-04-05 13:25:04 -0700161
162 ASSERT_TRUE(maps.Parse());
163 ASSERT_EQ(5U, maps.Total());
Christopher Ferrisbe788d82017-11-27 14:50:38 -0800164
165 MapInfo* info = maps.Get(0);
166 ASSERT_TRUE(info != nullptr);
167 EXPECT_EQ(PROT_NONE, info->flags);
168 EXPECT_EQ(0x1000U, info->start);
169 EXPECT_EQ(0x2000U, info->end);
170 EXPECT_EQ(0U, info->offset);
171 EXPECT_EQ("", info->name);
172
173 info = maps.Get(1);
174 ASSERT_TRUE(info != nullptr);
175 EXPECT_EQ(PROT_READ, info->flags);
176 EXPECT_EQ(0x2000U, info->start);
177 EXPECT_EQ(0x3000U, info->end);
178 EXPECT_EQ(0U, info->offset);
179 EXPECT_EQ("", info->name);
180
181 info = maps.Get(2);
182 ASSERT_TRUE(info != nullptr);
183 EXPECT_EQ(PROT_WRITE, info->flags);
184 EXPECT_EQ(0x3000U, info->start);
185 EXPECT_EQ(0x4000U, info->end);
186 EXPECT_EQ(0U, info->offset);
187 EXPECT_EQ("", info->name);
188
189 info = maps.Get(3);
190 ASSERT_TRUE(info != nullptr);
191 EXPECT_EQ(PROT_EXEC, info->flags);
192 EXPECT_EQ(0x4000U, info->start);
193 EXPECT_EQ(0x5000U, info->end);
194 EXPECT_EQ(0U, info->offset);
195 EXPECT_EQ("", info->name);
196
197 info = maps.Get(4);
198 ASSERT_TRUE(info != nullptr);
199 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info->flags);
200 EXPECT_EQ(0x5000U, info->start);
201 EXPECT_EQ(0x6000U, info->end);
202 EXPECT_EQ(0U, info->offset);
203 EXPECT_EQ("", info->name);
204
205 ASSERT_TRUE(maps.Get(5) == nullptr);
Christopher Ferris09385e72017-04-05 13:25:04 -0700206}
207
208TEST(MapsTest, parse_name) {
209 BufferMaps maps(
Christopher Ferris60521c72017-08-18 15:10:53 -0700210 "7b29b000-7b29e000 rw-p 00000000 00:00 0\n"
211 "7b29e000-7b29f000 rw-p 00000000 00:00 0 /system/lib/fake.so\n"
212 "7b29f000-7b2a0000 rw-p 00000000 00:00 0");
Christopher Ferris09385e72017-04-05 13:25:04 -0700213
214 ASSERT_TRUE(maps.Parse());
215 ASSERT_EQ(3U, maps.Total());
Christopher Ferrisbe788d82017-11-27 14:50:38 -0800216
217 MapInfo* info = maps.Get(0);
218 ASSERT_TRUE(info != nullptr);
219 EXPECT_EQ("", info->name);
220 EXPECT_EQ(0x7b29b000U, info->start);
221 EXPECT_EQ(0x7b29e000U, info->end);
222 EXPECT_EQ(0U, info->offset);
223 EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags);
224
225 info = maps.Get(1);
226 ASSERT_TRUE(info != nullptr);
227 EXPECT_EQ("/system/lib/fake.so", info->name);
228 EXPECT_EQ(0x7b29e000U, info->start);
229 EXPECT_EQ(0x7b29f000U, info->end);
230 EXPECT_EQ(0U, info->offset);
231 EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags);
232
233 info = maps.Get(2);
234 ASSERT_TRUE(info != nullptr);
235 EXPECT_EQ("", info->name);
236 EXPECT_EQ(0x7b29f000U, info->start);
237 EXPECT_EQ(0x7b2a0000U, info->end);
238 EXPECT_EQ(0U, info->offset);
239 EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags);
240
241 ASSERT_TRUE(maps.Get(3) == nullptr);
Christopher Ferris09385e72017-04-05 13:25:04 -0700242}
243
244TEST(MapsTest, parse_offset) {
245 BufferMaps maps(
246 "a000-e000 rw-p 00000000 00:00 0 /system/lib/fake.so\n"
247 "e000-f000 rw-p 00a12345 00:00 0 /system/lib/fake.so\n");
248
249 ASSERT_TRUE(maps.Parse());
250 ASSERT_EQ(2U, maps.Total());
Christopher Ferrisbe788d82017-11-27 14:50:38 -0800251
252 MapInfo* info = maps.Get(0);
253 ASSERT_TRUE(info != nullptr);
254 EXPECT_EQ(0U, info->offset);
255 EXPECT_EQ(0xa000U, info->start);
256 EXPECT_EQ(0xe000U, info->end);
257 EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags);
258 EXPECT_EQ("/system/lib/fake.so", info->name);
259
260 info = maps.Get(1);
261 ASSERT_TRUE(info != nullptr);
262 EXPECT_EQ(0xa12345U, info->offset);
263 EXPECT_EQ(0xe000U, info->start);
264 EXPECT_EQ(0xf000U, info->end);
265 EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags);
266 EXPECT_EQ("/system/lib/fake.so", info->name);
267
268 ASSERT_TRUE(maps.Get(2) == nullptr);
269}
270
271TEST(MapsTest, iterate) {
272 BufferMaps maps(
273 "a000-e000 rw-p 00000000 00:00 0 /system/lib/fake.so\n"
274 "e000-f000 rw-p 00a12345 00:00 0 /system/lib/fake.so\n");
275
276 ASSERT_TRUE(maps.Parse());
277 ASSERT_EQ(2U, maps.Total());
278
279 Maps::iterator it = maps.begin();
280 EXPECT_EQ(0xa000U, (*it)->start);
281 EXPECT_EQ(0xe000U, (*it)->end);
Christopher Ferris09385e72017-04-05 13:25:04 -0700282 ++it;
Christopher Ferrisbe788d82017-11-27 14:50:38 -0800283 EXPECT_EQ(0xe000U, (*it)->start);
284 EXPECT_EQ(0xf000U, (*it)->end);
Christopher Ferris09385e72017-04-05 13:25:04 -0700285 ++it;
Christopher Ferrisbe788d82017-11-27 14:50:38 -0800286 EXPECT_EQ(maps.end(), it);
287}
288
289TEST(MapsTest, const_iterate) {
290 BufferMaps maps(
291 "a000-e000 rw-p 00000000 00:00 0 /system/lib/fake.so\n"
292 "e000-f000 rw-p 00a12345 00:00 0 /system/lib/fake.so\n");
293
294 ASSERT_TRUE(maps.Parse());
295 ASSERT_EQ(2U, maps.Total());
296
297 Maps::const_iterator it = maps.begin();
298 EXPECT_EQ(0xa000U, (*it)->start);
299 EXPECT_EQ(0xe000U, (*it)->end);
300 ++it;
301 EXPECT_EQ(0xe000U, (*it)->start);
302 EXPECT_EQ(0xf000U, (*it)->end);
303 ++it;
304 EXPECT_EQ(maps.end(), it);
Christopher Ferris09385e72017-04-05 13:25:04 -0700305}
306
307TEST(MapsTest, device) {
308 BufferMaps maps(
309 "a000-e000 rw-p 00000000 00:00 0 /dev/\n"
310 "f000-f100 rw-p 00000000 00:00 0 /dev/does_not_exist\n"
311 "f100-f200 rw-p 00000000 00:00 0 /dev/ashmem/does_not_exist\n"
312 "f200-f300 rw-p 00000000 00:00 0 /devsomething/does_not_exist\n");
313
314 ASSERT_TRUE(maps.Parse());
315 ASSERT_EQ(4U, maps.Total());
Christopher Ferrisbe788d82017-11-27 14:50:38 -0800316
317 MapInfo* info = maps.Get(0);
318 ASSERT_TRUE(info != nullptr);
319 EXPECT_TRUE(info->flags & 0x8000);
320 EXPECT_EQ("/dev/", info->name);
321
322 info = maps.Get(1);
323 EXPECT_TRUE(info->flags & 0x8000);
324 EXPECT_EQ("/dev/does_not_exist", info->name);
325
326 info = maps.Get(2);
327 EXPECT_FALSE(info->flags & 0x8000);
328 EXPECT_EQ("/dev/ashmem/does_not_exist", info->name);
329
330 info = maps.Get(3);
331 EXPECT_FALSE(info->flags & 0x8000);
332 EXPECT_EQ("/devsomething/does_not_exist", info->name);
Christopher Ferris09385e72017-04-05 13:25:04 -0700333}
334
335TEST(MapsTest, file_smoke) {
336 TemporaryFile tf;
337 ASSERT_TRUE(tf.fd != -1);
338
339 ASSERT_TRUE(
Christopher Ferris60521c72017-08-18 15:10:53 -0700340 android::base::WriteStringToFile("7b29b000-7b29e000 r-xp a0000000 00:00 0 /fake.so\n"
341 "7b2b0000-7b2e0000 r-xp b0000000 00:00 0 /fake2.so\n"
342 "7b2e0000-7b2f0000 r-xp c0000000 00:00 0 /fake3.so\n",
Christopher Ferris09385e72017-04-05 13:25:04 -0700343 tf.path, 0660, getuid(), getgid()));
344
345 FileMaps maps(tf.path);
346
347 ASSERT_TRUE(maps.Parse());
348 ASSERT_EQ(3U, maps.Total());
Christopher Ferrisbe788d82017-11-27 14:50:38 -0800349
350 MapInfo* info = maps.Get(0);
351 ASSERT_TRUE(info != nullptr);
352 EXPECT_EQ(0x7b29b000U, info->start);
353 EXPECT_EQ(0x7b29e000U, info->end);
354 EXPECT_EQ(0xa0000000U, info->offset);
355 EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags);
356 EXPECT_EQ("/fake.so", info->name);
357
358 info = maps.Get(1);
359 ASSERT_TRUE(info != nullptr);
360 EXPECT_EQ(0x7b2b0000U, info->start);
361 EXPECT_EQ(0x7b2e0000U, info->end);
362 EXPECT_EQ(0xb0000000U, info->offset);
363 EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags);
364 EXPECT_EQ("/fake2.so", info->name);
365
366 info = maps.Get(2);
367 ASSERT_TRUE(info != nullptr);
368 EXPECT_EQ(0x7b2e0000U, info->start);
369 EXPECT_EQ(0x7b2f0000U, info->end);
370 EXPECT_EQ(0xc0000000U, info->offset);
371 EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags);
372 EXPECT_EQ("/fake3.so", info->name);
373
374 ASSERT_TRUE(maps.Get(3) == nullptr);
Christopher Ferris09385e72017-04-05 13:25:04 -0700375}
376
Christopher Ferris60521c72017-08-18 15:10:53 -0700377TEST(MapsTest, file_no_map_name) {
378 TemporaryFile tf;
379 ASSERT_TRUE(tf.fd != -1);
380
381 ASSERT_TRUE(
382 android::base::WriteStringToFile("7b29b000-7b29e000 r-xp a0000000 00:00 0\n"
383 "7b2b0000-7b2e0000 r-xp b0000000 00:00 0 /fake2.so\n"
384 "7b2e0000-7b2f0000 r-xp c0000000 00:00 0 \n",
385 tf.path, 0660, getuid(), getgid()));
386
387 FileMaps maps(tf.path);
388
389 ASSERT_TRUE(maps.Parse());
390 ASSERT_EQ(3U, maps.Total());
Christopher Ferrisbe788d82017-11-27 14:50:38 -0800391
392 MapInfo* info = maps.Get(0);
393 ASSERT_TRUE(info != nullptr);
394 EXPECT_EQ(0x7b29b000U, info->start);
395 EXPECT_EQ(0x7b29e000U, info->end);
396 EXPECT_EQ(0xa0000000U, info->offset);
397 EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags);
398 EXPECT_EQ("", info->name);
399
400 info = maps.Get(1);
401 ASSERT_TRUE(info != nullptr);
402 EXPECT_EQ(0x7b2b0000U, info->start);
403 EXPECT_EQ(0x7b2e0000U, info->end);
404 EXPECT_EQ(0xb0000000U, info->offset);
405 EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags);
406 EXPECT_EQ("/fake2.so", info->name);
407
408 info = maps.Get(2);
409 ASSERT_TRUE(info != nullptr);
410 EXPECT_EQ(0x7b2e0000U, info->start);
411 EXPECT_EQ(0x7b2f0000U, info->end);
412 EXPECT_EQ(0xc0000000U, info->offset);
413 EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags);
414 EXPECT_EQ("", info->name);
415
416 ASSERT_TRUE(maps.Get(3) == nullptr);
Christopher Ferris60521c72017-08-18 15:10:53 -0700417}
418
419// Verify that a file that crosses a buffer is parsed correctly.
420static std::string CreateEntry(size_t index) {
421 return android::base::StringPrintf("%08zx-%08zx rwxp 0000 00:00 0\n", index * 4096,
422 (index + 1) * 4096);
423}
424
425TEST(MapsTest, file_buffer_cross) {
426 constexpr size_t kBufferSize = 2048;
427 TemporaryFile tf;
428 ASSERT_TRUE(tf.fd != -1);
429
430 // Compute how many to add in the first buffer.
431 size_t entry_len = CreateEntry(0).size();
432 size_t index;
433 std::string file_data;
434 for (index = 0; index < kBufferSize / entry_len; index++) {
435 file_data += CreateEntry(index);
436 }
437 // Add a long name to make sure that the first buffer does not contain a
438 // complete line.
439 // Remove the last newline.
440 size_t extra = 0;
441 size_t leftover = kBufferSize % entry_len;
442 size_t overlap1_index = 0;
443 std::string overlap1_name;
444 if (leftover == 0) {
445 // Exact match, add a long name to cross over the value.
446 overlap1_name = "/fake/name/is/long/on/purpose";
447 file_data.erase(file_data.size() - 1);
448 file_data += ' ' + overlap1_name + '\n';
449 extra = entry_len + overlap1_name.size() + 1;
450 overlap1_index = index;
451 }
452
453 // Compute how many need to go in to hit the buffer boundary exactly.
454 size_t bytes_left_in_buffer = kBufferSize - extra;
455 size_t entries_to_add = bytes_left_in_buffer / entry_len + index;
456 for (; index < entries_to_add; index++) {
457 file_data += CreateEntry(index);
458 }
459
460 // Now figure out how many bytes to add to get exactly to the buffer boundary.
461 leftover = bytes_left_in_buffer % entry_len;
462 std::string overlap2_name;
463 size_t overlap2_index = 0;
464 if (leftover != 0) {
465 file_data.erase(file_data.size() - 1);
466 file_data += ' ';
467 overlap2_name = std::string(leftover - 1, 'x');
468 file_data += overlap2_name + '\n';
469 overlap2_index = index - 1;
470 }
471
472 // Now add a few entries on the next page.
473 for (size_t start = index; index < start + 10; index++) {
474 file_data += CreateEntry(index);
475 }
476
477 ASSERT_TRUE(android::base::WriteStringToFile(file_data, tf.path, 0660, getuid(), getgid()));
478
479 FileMaps maps(tf.path);
480 ASSERT_TRUE(maps.Parse());
481 EXPECT_EQ(index, maps.Total());
482 // Verify all of the maps.
483 for (size_t i = 0; i < index; i++) {
484 MapInfo* info = maps.Get(i);
485 ASSERT_TRUE(info != nullptr) << "Failed verifying index " + std::to_string(i);
486 EXPECT_EQ(i * 4096, info->start) << "Failed verifying index " + std::to_string(i);
487 EXPECT_EQ((i + 1) * 4096, info->end) << "Failed verifying index " + std::to_string(i);
488 EXPECT_EQ(0U, info->offset) << "Failed verifying index " + std::to_string(i);
489 if (overlap1_index != 0 && i == overlap1_index) {
490 EXPECT_EQ(overlap1_name, info->name) << "Failed verifying overlap1 name " + std::to_string(i);
491 } else if (overlap2_index != 0 && i == overlap2_index) {
492 EXPECT_EQ(overlap2_name, info->name) << "Failed verifying overlap2 name " + std::to_string(i);
493 } else {
494 EXPECT_EQ("", info->name) << "Failed verifying index " + std::to_string(i);
495 }
496 }
497}
498
499TEST(MapsTest, file_should_fail) {
500 TemporaryFile tf;
501 ASSERT_TRUE(tf.fd != -1);
502
503 ASSERT_TRUE(android::base::WriteStringToFile(
504 "7ffff7dda000-7ffff7dfd7ffff7ff3000-7ffff7ff4000 ---p 0000f000 fc:02 44171565\n", tf.path,
505 0660, getuid(), getgid()));
506
507 FileMaps maps(tf.path);
508
509 ASSERT_FALSE(maps.Parse());
510}
511
512// Create a maps file that is extremely large.
513TEST(MapsTest, large_file) {
514 TemporaryFile tf;
515 ASSERT_TRUE(tf.fd != -1);
516
517 std::string file_data;
518 uint64_t start = 0x700000;
519 for (size_t i = 0; i < 5000; i++) {
520 file_data +=
521 android::base::StringPrintf("%" PRIx64 "-%" PRIx64 " r-xp 1000 00:0 0 /fake%zu.so\n",
522 start + i * 4096, start + (i + 1) * 4096, i);
523 }
524
525 ASSERT_TRUE(android::base::WriteStringToFile(file_data, tf.path, 0660, getuid(), getgid()));
526
527 FileMaps maps(tf.path);
528
529 ASSERT_TRUE(maps.Parse());
530 ASSERT_EQ(5000U, maps.Total());
531 for (size_t i = 0; i < 5000; i++) {
532 MapInfo* info = maps.Get(i);
Christopher Ferrisbe788d82017-11-27 14:50:38 -0800533 EXPECT_EQ(start + i * 4096, info->start) << "Failed at map " + std::to_string(i);
534 EXPECT_EQ(start + (i + 1) * 4096, info->end) << "Failed at map " + std::to_string(i);
Christopher Ferris60521c72017-08-18 15:10:53 -0700535 std::string name = "/fake" + std::to_string(i) + ".so";
Christopher Ferrisbe788d82017-11-27 14:50:38 -0800536 EXPECT_EQ(name, info->name) << "Failed at map " + std::to_string(i);
Christopher Ferris60521c72017-08-18 15:10:53 -0700537 }
538}
539
Christopher Ferris09385e72017-04-05 13:25:04 -0700540TEST(MapsTest, find) {
541 BufferMaps maps(
542 "1000-2000 r--p 00000010 00:00 0 /system/lib/fake1.so\n"
543 "3000-4000 -w-p 00000020 00:00 0 /system/lib/fake2.so\n"
544 "6000-8000 --xp 00000030 00:00 0 /system/lib/fake3.so\n"
545 "a000-b000 rw-p 00000040 00:00 0 /system/lib/fake4.so\n"
546 "e000-f000 rwxp 00000050 00:00 0 /system/lib/fake5.so\n");
547 ASSERT_TRUE(maps.Parse());
548 ASSERT_EQ(5U, maps.Total());
549
Christopher Ferrisbe788d82017-11-27 14:50:38 -0800550 EXPECT_TRUE(maps.Find(0x500) == nullptr);
551 EXPECT_TRUE(maps.Find(0x2000) == nullptr);
552 EXPECT_TRUE(maps.Find(0x5010) == nullptr);
553 EXPECT_TRUE(maps.Find(0x9a00) == nullptr);
554 EXPECT_TRUE(maps.Find(0xf000) == nullptr);
555 EXPECT_TRUE(maps.Find(0xf010) == nullptr);
Christopher Ferris09385e72017-04-05 13:25:04 -0700556
557 MapInfo* info = maps.Find(0x1000);
558 ASSERT_TRUE(info != nullptr);
Christopher Ferrisbe788d82017-11-27 14:50:38 -0800559 EXPECT_EQ(0x1000U, info->start);
560 EXPECT_EQ(0x2000U, info->end);
561 EXPECT_EQ(0x10U, info->offset);
562 EXPECT_EQ(PROT_READ, info->flags);
563 EXPECT_EQ("/system/lib/fake1.so", info->name);
Christopher Ferris09385e72017-04-05 13:25:04 -0700564
565 info = maps.Find(0x3020);
566 ASSERT_TRUE(info != nullptr);
Christopher Ferrisbe788d82017-11-27 14:50:38 -0800567 EXPECT_EQ(0x3000U, info->start);
568 EXPECT_EQ(0x4000U, info->end);
569 EXPECT_EQ(0x20U, info->offset);
570 EXPECT_EQ(PROT_WRITE, info->flags);
571 EXPECT_EQ("/system/lib/fake2.so", info->name);
Christopher Ferris09385e72017-04-05 13:25:04 -0700572
573 info = maps.Find(0x6020);
574 ASSERT_TRUE(info != nullptr);
Christopher Ferrisbe788d82017-11-27 14:50:38 -0800575 EXPECT_EQ(0x6000U, info->start);
576 EXPECT_EQ(0x8000U, info->end);
577 EXPECT_EQ(0x30U, info->offset);
578 EXPECT_EQ(PROT_EXEC, info->flags);
579 EXPECT_EQ("/system/lib/fake3.so", info->name);
Christopher Ferris09385e72017-04-05 13:25:04 -0700580
581 info = maps.Find(0xafff);
582 ASSERT_TRUE(info != nullptr);
Christopher Ferrisbe788d82017-11-27 14:50:38 -0800583 EXPECT_EQ(0xa000U, info->start);
584 EXPECT_EQ(0xb000U, info->end);
585 EXPECT_EQ(0x40U, info->offset);
586 EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags);
587 EXPECT_EQ("/system/lib/fake4.so", info->name);
Christopher Ferris09385e72017-04-05 13:25:04 -0700588
589 info = maps.Find(0xe500);
590 ASSERT_TRUE(info != nullptr);
Christopher Ferrisbe788d82017-11-27 14:50:38 -0800591 EXPECT_EQ(0xe000U, info->start);
592 EXPECT_EQ(0xf000U, info->end);
593 EXPECT_EQ(0x50U, info->offset);
594 EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info->flags);
595 EXPECT_EQ("/system/lib/fake5.so", info->name);
Christopher Ferris09385e72017-04-05 13:25:04 -0700596}
Christopher Ferrisd226a512017-07-14 10:37:19 -0700597
598} // namespace unwindstack