1 /*
2  * Copyright (C) 2019 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 <stdint.h>
18 #include <sys/mman.h>
19 
20 #include <string>
21 #include <vector>
22 
23 #include <gtest/gtest.h>
24 
25 #include <android-base/file.h>
26 #include <unwindstack/Maps.h>
27 
28 namespace unwindstack {
29 
30 class TestUpdatableMaps : public LocalUpdatableMaps {
31  public:
TestUpdatableMaps()32   TestUpdatableMaps() : LocalUpdatableMaps() {}
33   virtual ~TestUpdatableMaps() = default;
34 
GetMapsFile() const35   const std::string GetMapsFile() const override { return maps_file_; }
36 
TestSetMapsFile(const std::string & maps_file)37   void TestSetMapsFile(const std::string& maps_file) { maps_file_ = maps_file; }
38 
TestGetSavedMaps()39   const std::vector<std::unique_ptr<MapInfo>>& TestGetSavedMaps() { return saved_maps_; }
40 
41  private:
42   std::string maps_file_;
43 };
44 
45 class LocalUpdatableMapsTest : public ::testing::Test {
46  protected:
GetDefaultMapString()47   static const std::string GetDefaultMapString() {
48     return "3000-4000 r-xp 00000 00:00 0\n8000-9000 r-xp 00000 00:00 0\n";
49   }
50 
SetUp()51   void SetUp() override {
52     TemporaryFile tf;
53     ASSERT_TRUE(android::base::WriteStringToFile(GetDefaultMapString(), tf.path));
54 
55     maps_.TestSetMapsFile(tf.path);
56     ASSERT_TRUE(maps_.Parse());
57     ASSERT_EQ(2U, maps_.Total());
58 
59     MapInfo* map_info = maps_.Get(0);
60     ASSERT_TRUE(map_info != nullptr);
61     EXPECT_EQ(0x3000U, map_info->start());
62     EXPECT_EQ(0x4000U, map_info->end());
63     EXPECT_EQ(0U, map_info->offset());
64     EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
65     EXPECT_TRUE(map_info->name().empty());
66 
67     map_info = maps_.Get(1);
68     ASSERT_TRUE(map_info != nullptr);
69     EXPECT_EQ(0x8000U, map_info->start());
70     EXPECT_EQ(0x9000U, map_info->end());
71     EXPECT_EQ(0U, map_info->offset());
72     EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
73     EXPECT_TRUE(map_info->name().empty());
74   }
75 
76   TestUpdatableMaps maps_;
77 };
78 
TEST_F(LocalUpdatableMapsTest,same_map)79 TEST_F(LocalUpdatableMapsTest, same_map) {
80   TemporaryFile tf;
81   ASSERT_TRUE(android::base::WriteStringToFile(GetDefaultMapString(), tf.path));
82 
83   maps_.TestSetMapsFile(tf.path);
84   ASSERT_TRUE(maps_.Reparse());
85   ASSERT_EQ(2U, maps_.Total());
86   EXPECT_EQ(0U, maps_.TestGetSavedMaps().size());
87 
88   MapInfo* map_info = maps_.Get(0);
89   ASSERT_TRUE(map_info != nullptr);
90   EXPECT_EQ(0x3000U, map_info->start());
91   EXPECT_EQ(0x4000U, map_info->end());
92   EXPECT_EQ(0U, map_info->offset());
93   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
94   EXPECT_TRUE(map_info->name().empty());
95 
96   map_info = maps_.Get(1);
97   ASSERT_TRUE(map_info != nullptr);
98   EXPECT_EQ(0x8000U, map_info->start());
99   EXPECT_EQ(0x9000U, map_info->end());
100   EXPECT_EQ(0U, map_info->offset());
101   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
102   EXPECT_TRUE(map_info->name().empty());
103 }
104 
TEST_F(LocalUpdatableMapsTest,same_map_new_perms)105 TEST_F(LocalUpdatableMapsTest, same_map_new_perms) {
106   TemporaryFile tf;
107   ASSERT_TRUE(
108       android::base::WriteStringToFile("3000-4000 rwxp 00000 00:00 0\n"
109                                        "8000-9000 r-xp 00000 00:00 0\n",
110                                        tf.path));
111 
112   maps_.TestSetMapsFile(tf.path);
113   ASSERT_TRUE(maps_.Reparse());
114   ASSERT_EQ(2U, maps_.Total());
115 
116   MapInfo* map_info = maps_.Get(0);
117   ASSERT_TRUE(map_info != nullptr);
118   EXPECT_EQ(0x3000U, map_info->start());
119   EXPECT_EQ(0x4000U, map_info->end());
120   EXPECT_EQ(0U, map_info->offset());
121   EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, map_info->flags());
122   EXPECT_TRUE(map_info->name().empty());
123 
124   map_info = maps_.Get(1);
125   ASSERT_TRUE(map_info != nullptr);
126   EXPECT_EQ(0x8000U, map_info->start());
127   EXPECT_EQ(0x9000U, map_info->end());
128   EXPECT_EQ(0U, map_info->offset());
129   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
130   EXPECT_TRUE(map_info->name().empty());
131 
132   auto& saved_maps = maps_.TestGetSavedMaps();
133   ASSERT_EQ(1U, saved_maps.size());
134   map_info = saved_maps[0].get();
135   ASSERT_TRUE(map_info != nullptr);
136   EXPECT_EQ(0x3000U, map_info->start());
137   EXPECT_EQ(0x4000U, map_info->end());
138   EXPECT_EQ(0U, map_info->offset());
139   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
140   EXPECT_TRUE(map_info->name().empty());
141 }
142 
TEST_F(LocalUpdatableMapsTest,same_map_new_name)143 TEST_F(LocalUpdatableMapsTest, same_map_new_name) {
144   TemporaryFile tf;
145   ASSERT_TRUE(
146       android::base::WriteStringToFile("3000-4000 r-xp 00000 00:00 0 /fake/lib.so\n"
147                                        "8000-9000 r-xp 00000 00:00 0\n",
148                                        tf.path));
149 
150   maps_.TestSetMapsFile(tf.path);
151   ASSERT_TRUE(maps_.Reparse());
152   ASSERT_EQ(2U, maps_.Total());
153 
154   MapInfo* map_info = maps_.Get(0);
155   ASSERT_TRUE(map_info != nullptr);
156   EXPECT_EQ(0x3000U, map_info->start());
157   EXPECT_EQ(0x4000U, map_info->end());
158   EXPECT_EQ(0U, map_info->offset());
159   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
160   EXPECT_EQ("/fake/lib.so", map_info->name());
161 
162   map_info = maps_.Get(1);
163   ASSERT_TRUE(map_info != nullptr);
164   EXPECT_EQ(0x8000U, map_info->start());
165   EXPECT_EQ(0x9000U, map_info->end());
166   EXPECT_EQ(0U, map_info->offset());
167   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
168   EXPECT_TRUE(map_info->name().empty());
169 
170   auto& saved_maps = maps_.TestGetSavedMaps();
171   ASSERT_EQ(1U, saved_maps.size());
172   map_info = saved_maps[0].get();
173   ASSERT_TRUE(map_info != nullptr);
174   EXPECT_EQ(0x3000U, map_info->start());
175   EXPECT_EQ(0x4000U, map_info->end());
176   EXPECT_EQ(0U, map_info->offset());
177   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
178   EXPECT_TRUE(map_info->name().empty());
179 }
180 
TEST_F(LocalUpdatableMapsTest,only_add_maps)181 TEST_F(LocalUpdatableMapsTest, only_add_maps) {
182   TemporaryFile tf;
183   ASSERT_TRUE(
184       android::base::WriteStringToFile("1000-2000 r-xp 00000 00:00 0\n"
185                                        "3000-4000 r-xp 00000 00:00 0\n"
186                                        "8000-9000 r-xp 00000 00:00 0\n"
187                                        "a000-f000 r-xp 00000 00:00 0\n",
188                                        tf.path));
189 
190   maps_.TestSetMapsFile(tf.path);
191   ASSERT_TRUE(maps_.Reparse());
192   ASSERT_EQ(4U, maps_.Total());
193   EXPECT_EQ(0U, maps_.TestGetSavedMaps().size());
194 
195   MapInfo* map_info = maps_.Get(0);
196   ASSERT_TRUE(map_info != nullptr);
197   EXPECT_EQ(0x1000U, map_info->start());
198   EXPECT_EQ(0x2000U, map_info->end());
199   EXPECT_EQ(0U, map_info->offset());
200   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
201   EXPECT_TRUE(map_info->name().empty());
202 
203   map_info = maps_.Get(1);
204   ASSERT_TRUE(map_info != nullptr);
205   EXPECT_EQ(0x3000U, map_info->start());
206   EXPECT_EQ(0x4000U, map_info->end());
207   EXPECT_EQ(0U, map_info->offset());
208   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
209   EXPECT_TRUE(map_info->name().empty());
210 
211   map_info = maps_.Get(2);
212   ASSERT_TRUE(map_info != nullptr);
213   EXPECT_EQ(0x8000U, map_info->start());
214   EXPECT_EQ(0x9000U, map_info->end());
215   EXPECT_EQ(0U, map_info->offset());
216   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
217   EXPECT_TRUE(map_info->name().empty());
218 
219   map_info = maps_.Get(3);
220   ASSERT_TRUE(map_info != nullptr);
221   EXPECT_EQ(0xa000U, map_info->start());
222   EXPECT_EQ(0xf000U, map_info->end());
223   EXPECT_EQ(0U, map_info->offset());
224   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
225   EXPECT_TRUE(map_info->name().empty());
226 }
227 
TEST_F(LocalUpdatableMapsTest,all_new_maps)228 TEST_F(LocalUpdatableMapsTest, all_new_maps) {
229   TemporaryFile tf;
230   ASSERT_TRUE(
231       android::base::WriteStringToFile("1000-2000 r-xp 00000 00:00 0\n"
232                                        "a000-f000 r-xp 00000 00:00 0\n",
233                                        tf.path));
234 
235   maps_.TestSetMapsFile(tf.path);
236   ASSERT_TRUE(maps_.Reparse());
237   ASSERT_EQ(2U, maps_.Total());
238 
239   MapInfo* map_info = maps_.Get(0);
240   ASSERT_TRUE(map_info != nullptr);
241   EXPECT_EQ(0x1000U, map_info->start());
242   EXPECT_EQ(0x2000U, map_info->end());
243   EXPECT_EQ(0U, map_info->offset());
244   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
245   EXPECT_TRUE(map_info->name().empty());
246 
247   map_info = maps_.Get(1);
248   ASSERT_TRUE(map_info != nullptr);
249   EXPECT_EQ(0xa000U, map_info->start());
250   EXPECT_EQ(0xf000U, map_info->end());
251   EXPECT_EQ(0U, map_info->offset());
252   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
253   EXPECT_TRUE(map_info->name().empty());
254 
255   auto& saved_maps = maps_.TestGetSavedMaps();
256   ASSERT_EQ(2U, saved_maps.size());
257   map_info = saved_maps[0].get();
258   ASSERT_TRUE(map_info != nullptr);
259   EXPECT_EQ(0x3000U, map_info->start());
260   EXPECT_EQ(0x4000U, map_info->end());
261   EXPECT_EQ(0U, map_info->offset());
262   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
263   EXPECT_TRUE(map_info->name().empty());
264 
265   map_info = saved_maps[1].get();
266   ASSERT_TRUE(map_info != nullptr);
267   EXPECT_EQ(0x8000U, map_info->start());
268   EXPECT_EQ(0x9000U, map_info->end());
269   EXPECT_EQ(0U, map_info->offset());
270   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
271   EXPECT_TRUE(map_info->name().empty());
272 }
273 
TEST_F(LocalUpdatableMapsTest,add_map_prev_name_updated)274 TEST_F(LocalUpdatableMapsTest, add_map_prev_name_updated) {
275   TemporaryFile tf;
276   ASSERT_TRUE(
277       android::base::WriteStringToFile("3000-4000 rwxp 00000 00:00 0\n"
278                                        "8000-9000 r-xp 00000 00:00 0\n"
279                                        "9000-a000 r-xp 00000 00:00 0\n",
280                                        tf.path));
281 
282   maps_.TestSetMapsFile(tf.path);
283   ASSERT_TRUE(maps_.Reparse());
284   ASSERT_EQ(3U, maps_.Total());
285 
286   MapInfo* map_info = maps_.Get(2);
287   ASSERT_TRUE(map_info != nullptr);
288   EXPECT_EQ(0x9000U, map_info->start());
289   EXPECT_EQ(0xA000U, map_info->end());
290   EXPECT_EQ(0U, map_info->offset());
291   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
292   EXPECT_TRUE(map_info->name().empty());
293   EXPECT_EQ(maps_.Get(1), map_info->prev_map());
294 }
295 
TEST_F(LocalUpdatableMapsTest,add_map_prev_real_name_updated)296 TEST_F(LocalUpdatableMapsTest, add_map_prev_real_name_updated) {
297   TemporaryFile tf;
298   ASSERT_TRUE(
299       android::base::WriteStringToFile("3000-4000 r-xp 00000 00:00 0 /fake/lib.so\n"
300                                        "4000-5000 ---p 00000 00:00 0\n"
301                                        "7000-8000 r-xp 00000 00:00 0 /fake/lib1.so\n"
302                                        "8000-9000 ---p 00000 00:00 0\n",
303                                        tf.path));
304 
305   maps_.TestSetMapsFile(tf.path);
306   bool any_changed;
307   ASSERT_TRUE(maps_.Reparse(&any_changed));
308   ASSERT_EQ(4U, maps_.Total());
309   ASSERT_TRUE(any_changed);
310 
311   // Try again and assert there are no changes this time.
312   ASSERT_TRUE(maps_.Reparse(&any_changed));
313   ASSERT_EQ(4U, maps_.Total());
314   ASSERT_FALSE(any_changed);
315 
316   MapInfo* map_info = maps_.Get(2);
317   ASSERT_TRUE(map_info != nullptr);
318   EXPECT_EQ(0x7000U, map_info->start());
319   EXPECT_EQ(0x8000U, map_info->end());
320   EXPECT_EQ(0U, map_info->offset());
321   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
322   EXPECT_EQ(maps_.Get(0), map_info->prev_real_map());
323   EXPECT_EQ(maps_.Get(1), map_info->prev_map());
324   EXPECT_EQ("/fake/lib1.so", map_info->name());
325 
326   map_info = maps_.Get(3);
327   ASSERT_TRUE(map_info != nullptr);
328   EXPECT_EQ(0x8000U, map_info->start());
329   EXPECT_EQ(0x9000U, map_info->end());
330   EXPECT_EQ(0U, map_info->offset());
331   EXPECT_TRUE(map_info->IsBlank());
332   EXPECT_EQ(maps_.Get(2), map_info->prev_real_map());
333   EXPECT_EQ(maps_.Get(2), map_info->prev_map());
334   EXPECT_TRUE(map_info->name().empty());
335 
336   ASSERT_TRUE(
337       android::base::WriteStringToFile("3000-4000 r-xp 00000 00:00 0 /fake/lib.so\n"
338                                        "4000-5000 ---p 00000 00:00 0\n"
339                                        "7000-8000 r-xp 00000 00:00 0 /fake/lib1.so\n"
340                                        "8000-9000 ---p 00000 00:00 0\n"
341                                        "9000-a000 r-xp 00000 00:00 0 /fake/lib2.so\n"
342                                        "a000-b000 r-xp 00000 00:00 0 /fake/lib3.so\n",
343                                        tf.path));
344 
345   maps_.TestSetMapsFile(tf.path);
346   ASSERT_TRUE(maps_.Reparse(&any_changed));
347   ASSERT_EQ(6U, maps_.Total());
348   ASSERT_TRUE(any_changed);
349 
350   // Try again and assert there are no changes this time.
351   ASSERT_TRUE(maps_.Reparse(&any_changed));
352   ASSERT_EQ(6U, maps_.Total());
353   ASSERT_FALSE(any_changed);
354 
355   map_info = maps_.Get(2);
356   ASSERT_TRUE(map_info != nullptr);
357   EXPECT_EQ(0x7000U, map_info->start());
358   EXPECT_EQ(0x8000U, map_info->end());
359   EXPECT_EQ(0U, map_info->offset());
360   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
361   EXPECT_EQ("/fake/lib1.so", map_info->name());
362   EXPECT_EQ(maps_.Get(1), map_info->prev_map());
363   EXPECT_EQ(maps_.Get(0), map_info->prev_real_map());
364 
365   map_info = maps_.Get(4);
366   ASSERT_TRUE(map_info != nullptr);
367   EXPECT_EQ(0x9000U, map_info->start());
368   EXPECT_EQ(0xA000U, map_info->end());
369   EXPECT_EQ(0U, map_info->offset());
370   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
371   EXPECT_EQ("/fake/lib2.so", map_info->name());
372   EXPECT_EQ(maps_.Get(3), map_info->prev_map());
373   EXPECT_EQ(maps_.Get(2), map_info->prev_real_map());
374 
375   map_info = maps_.Get(5);
376   ASSERT_TRUE(map_info != nullptr);
377   EXPECT_EQ(0xA000U, map_info->start());
378   EXPECT_EQ(0xB000U, map_info->end());
379   EXPECT_EQ(0U, map_info->offset());
380   EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags());
381   EXPECT_EQ("/fake/lib3.so", map_info->name());
382   EXPECT_EQ(maps_.Get(4), map_info->prev_map());
383   EXPECT_EQ(maps_.Get(4), map_info->prev_real_map());
384 }
385 
386 }  // namespace unwindstack
387