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