1 // Copyright 2014 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifdef UNSAFE_BUFFERS_BUILD
6 // TODO(crbug.com/40284755): Remove this and spanify to fix the errors.
7 #pragma allow_unsafe_buffers
8 #endif
9
10 #include "base/files/memory_mapped_file.h"
11
12 #include <stddef.h>
13 #include <stdint.h>
14
15 #include <optional>
16 #include <utility>
17
18 #include "base/containers/heap_array.h"
19 #include "base/containers/span.h"
20 #include "base/files/file_path.h"
21 #include "base/files/file_util.h"
22 #if BUILDFLAG(IS_WIN)
23 #include "base/path_service.h"
24 #endif // BUILDFLAG(IS_WIN)
25 #include "testing/gtest/include/gtest/gtest.h"
26 #include "testing/platform_test.h"
27
28 namespace base {
29
30 namespace {
31
32 // Create a temporary buffer and fill it with a watermark sequence.
CreateTestBuffer(size_t size,size_t offset)33 base::HeapArray<uint8_t> CreateTestBuffer(size_t size, size_t offset) {
34 auto buf = base::HeapArray<uint8_t>::Uninit(size);
35 for (size_t i = 0; i < size; ++i)
36 buf[i] = static_cast<uint8_t>((offset + i) % 253);
37 return buf;
38 }
39
40 // Check that the watermark sequence is consistent with the |offset| provided.
CheckBufferContents(span<const uint8_t> bytes,size_t offset)41 bool CheckBufferContents(span<const uint8_t> bytes, size_t offset) {
42 base::HeapArray<uint8_t> test_data(CreateTestBuffer(bytes.size(), offset));
43 return test_data.as_span() == bytes;
44 }
45
46 class MemoryMappedFileTest : public PlatformTest {
47 protected:
SetUp()48 void SetUp() override {
49 PlatformTest::SetUp();
50 CreateTemporaryFile(&temp_file_path_);
51 }
52
TearDown()53 void TearDown() override { EXPECT_TRUE(DeleteFile(temp_file_path_)); }
54
CreateTemporaryTestFile(size_t size)55 void CreateTemporaryTestFile(size_t size) {
56 File file(temp_file_path_,
57 File::FLAG_CREATE_ALWAYS | File::FLAG_READ | File::FLAG_WRITE);
58 EXPECT_TRUE(file.IsValid());
59
60 base::HeapArray<uint8_t> test_data(CreateTestBuffer(size, 0));
61 size_t bytes_written = file.Write(0, test_data.as_span()).value();
62 EXPECT_EQ(size, bytes_written);
63 file.Close();
64 }
65
temp_file_path() const66 const FilePath temp_file_path() const { return temp_file_path_; }
67
68 private:
69 FilePath temp_file_path_;
70 };
71
TEST_F(MemoryMappedFileTest,MapWholeFileByPath)72 TEST_F(MemoryMappedFileTest, MapWholeFileByPath) {
73 const size_t kFileSize = 68 * 1024;
74 CreateTemporaryTestFile(kFileSize);
75 MemoryMappedFile map;
76 ASSERT_TRUE(map.Initialize(temp_file_path()));
77 ASSERT_EQ(kFileSize, map.length());
78 ASSERT_TRUE(map.data() != nullptr);
79 EXPECT_TRUE(map.IsValid());
80 ASSERT_TRUE(CheckBufferContents(map.bytes(), 0));
81 }
82
TEST_F(MemoryMappedFileTest,MapWholeFileByFD)83 TEST_F(MemoryMappedFileTest, MapWholeFileByFD) {
84 const size_t kFileSize = 68 * 1024;
85 CreateTemporaryTestFile(kFileSize);
86 MemoryMappedFile map;
87 ASSERT_TRUE(map.Initialize(
88 File(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ)));
89 ASSERT_EQ(kFileSize, map.length());
90 ASSERT_TRUE(map.data() != nullptr);
91 EXPECT_TRUE(map.IsValid());
92 ASSERT_TRUE(CheckBufferContents(map.bytes(), 0));
93 }
94
TEST_F(MemoryMappedFileTest,MapSmallFile)95 TEST_F(MemoryMappedFileTest, MapSmallFile) {
96 const size_t kFileSize = 127;
97 CreateTemporaryTestFile(kFileSize);
98 MemoryMappedFile map;
99 ASSERT_TRUE(map.Initialize(temp_file_path()));
100 ASSERT_EQ(kFileSize, map.length());
101 ASSERT_TRUE(map.data() != nullptr);
102 EXPECT_TRUE(map.IsValid());
103 ASSERT_TRUE(CheckBufferContents(map.bytes(), 0));
104 }
105
TEST_F(MemoryMappedFileTest,MapWholeFileUsingRegion)106 TEST_F(MemoryMappedFileTest, MapWholeFileUsingRegion) {
107 const size_t kFileSize = 157 * 1024;
108 CreateTemporaryTestFile(kFileSize);
109 MemoryMappedFile map;
110
111 File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
112 ASSERT_TRUE(
113 map.Initialize(std::move(file), MemoryMappedFile::Region::kWholeFile));
114 ASSERT_EQ(kFileSize, map.length());
115 ASSERT_TRUE(map.data() != nullptr);
116 EXPECT_TRUE(map.IsValid());
117 ASSERT_TRUE(CheckBufferContents(map.bytes(), 0));
118 }
119
TEST_F(MemoryMappedFileTest,MapPartialRegionAtBeginning)120 TEST_F(MemoryMappedFileTest, MapPartialRegionAtBeginning) {
121 const size_t kFileSize = 157 * 1024;
122 const size_t kPartialSize = 4 * 1024 + 32;
123 CreateTemporaryTestFile(kFileSize);
124 MemoryMappedFile map;
125
126 File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
127 MemoryMappedFile::Region region = {0, kPartialSize};
128 ASSERT_TRUE(map.Initialize(std::move(file), region));
129 ASSERT_EQ(kPartialSize, map.length());
130 ASSERT_TRUE(map.data() != nullptr);
131 EXPECT_TRUE(map.IsValid());
132 ASSERT_TRUE(CheckBufferContents(map.bytes().first<kPartialSize>(), 0));
133 }
134
TEST_F(MemoryMappedFileTest,MapPartialRegionAtEnd)135 TEST_F(MemoryMappedFileTest, MapPartialRegionAtEnd) {
136 const size_t kFileSize = 157 * 1024;
137 const size_t kPartialSize = 5 * 1024 - 32;
138 const size_t kOffset = kFileSize - kPartialSize;
139 CreateTemporaryTestFile(kFileSize);
140 MemoryMappedFile map;
141
142 File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
143 MemoryMappedFile::Region region = {kOffset, kPartialSize};
144 ASSERT_TRUE(map.Initialize(std::move(file), region));
145 ASSERT_EQ(kPartialSize, map.length());
146 ASSERT_TRUE(map.data() != nullptr);
147 EXPECT_TRUE(map.IsValid());
148 ASSERT_TRUE(CheckBufferContents(map.bytes().first<kPartialSize>(), kOffset));
149 }
150
TEST_F(MemoryMappedFileTest,MapSmallPartialRegionInTheMiddle)151 TEST_F(MemoryMappedFileTest, MapSmallPartialRegionInTheMiddle) {
152 const size_t kFileSize = 157 * 1024;
153 const size_t kOffset = 1024 * 5 + 32;
154 const size_t kPartialSize = 8;
155
156 CreateTemporaryTestFile(kFileSize);
157 MemoryMappedFile map;
158
159 File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
160 MemoryMappedFile::Region region = {kOffset, kPartialSize};
161 ASSERT_TRUE(map.Initialize(std::move(file), region));
162 ASSERT_EQ(kPartialSize, map.length());
163 ASSERT_TRUE(map.data() != nullptr);
164 EXPECT_TRUE(map.IsValid());
165 ASSERT_TRUE(CheckBufferContents(map.bytes().first<kPartialSize>(), kOffset));
166 }
167
TEST_F(MemoryMappedFileTest,MapLargePartialRegionInTheMiddle)168 TEST_F(MemoryMappedFileTest, MapLargePartialRegionInTheMiddle) {
169 const size_t kFileSize = 157 * 1024;
170 const size_t kOffset = 1024 * 5 + 32;
171 const size_t kPartialSize = 16 * 1024 - 32;
172
173 CreateTemporaryTestFile(kFileSize);
174 MemoryMappedFile map;
175
176 File file(temp_file_path(), File::FLAG_OPEN | File::FLAG_READ);
177 MemoryMappedFile::Region region = {kOffset, kPartialSize};
178 ASSERT_TRUE(map.Initialize(std::move(file), region));
179 ASSERT_EQ(kPartialSize, map.length());
180 ASSERT_TRUE(map.data() != nullptr);
181 EXPECT_TRUE(map.IsValid());
182 ASSERT_TRUE(CheckBufferContents(map.bytes().first<kPartialSize>(), kOffset));
183 }
184
TEST_F(MemoryMappedFileTest,WriteableFile)185 TEST_F(MemoryMappedFileTest, WriteableFile) {
186 const size_t kFileSize = 127;
187 CreateTemporaryTestFile(kFileSize);
188
189 {
190 MemoryMappedFile map;
191 ASSERT_TRUE(map.Initialize(temp_file_path(), MemoryMappedFile::READ_WRITE));
192 ASSERT_EQ(kFileSize, map.length());
193 ASSERT_TRUE(map.data() != nullptr);
194 EXPECT_TRUE(map.IsValid());
195 ASSERT_TRUE(CheckBufferContents(map.bytes(), 0));
196
197 span<uint8_t> bytes = map.mutable_bytes();
198 bytes[0] = 'B';
199 bytes[1] = 'a';
200 bytes[2] = 'r';
201 bytes[kFileSize - 1] = '!';
202 EXPECT_FALSE(CheckBufferContents(map.bytes(), 0));
203 EXPECT_TRUE(CheckBufferContents(
204 map.bytes().first<kFileSize - 1>().subspan<3>(), 3));
205 }
206
207 std::optional<int64_t> file_size = GetFileSize(temp_file_path());
208 ASSERT_TRUE(file_size.has_value());
209 EXPECT_EQ(static_cast<int64_t>(kFileSize), file_size.value());
210
211 std::string contents;
212 ASSERT_TRUE(ReadFileToString(temp_file_path(), &contents));
213 EXPECT_EQ("Bar", contents.substr(0, 3));
214 EXPECT_EQ("!", contents.substr(kFileSize - 1, 1));
215 }
216
TEST_F(MemoryMappedFileTest,CopyOnWrite)217 TEST_F(MemoryMappedFileTest, CopyOnWrite) {
218 const size_t kFileSize = 127;
219 CreateTemporaryTestFile(kFileSize);
220
221 {
222 MemoryMappedFile map;
223 ASSERT_TRUE(
224 map.Initialize(temp_file_path(), MemoryMappedFile::READ_WRITE_COPY));
225 ASSERT_EQ(kFileSize, map.length());
226 ASSERT_TRUE(map.data() != nullptr);
227 EXPECT_TRUE(map.IsValid());
228 ASSERT_TRUE(CheckBufferContents(map.bytes(), 0));
229
230 span<uint8_t> bytes = map.mutable_bytes();
231 bytes[0] = 'B';
232 bytes[1] = 'a';
233 bytes[2] = 'r';
234 bytes[kFileSize - 1] = '!';
235 EXPECT_FALSE(CheckBufferContents(map.bytes(), 0));
236 EXPECT_TRUE(CheckBufferContents(
237 map.bytes().first<kFileSize - 1>().subspan<3>(), 3));
238 }
239
240 std::optional<int64_t> file_size = GetFileSize(temp_file_path());
241 ASSERT_TRUE(file_size.has_value());
242 EXPECT_EQ(static_cast<int64_t>(kFileSize), file_size.value());
243
244 // Although the buffer has been modified in memory, the file is unchanged.
245 std::string contents;
246 ASSERT_TRUE(ReadFileToString(temp_file_path(), &contents));
247 EXPECT_TRUE(CheckBufferContents(as_bytes(span(contents)), 0));
248 }
249
TEST_F(MemoryMappedFileTest,ExtendableFile)250 TEST_F(MemoryMappedFileTest, ExtendableFile) {
251 const size_t kFileSize = 127;
252 const size_t kFileExtend = 100;
253 CreateTemporaryTestFile(kFileSize);
254
255 {
256 File file(temp_file_path(),
257 File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WRITE);
258 MemoryMappedFile::Region region = {0, kFileSize + kFileExtend};
259 MemoryMappedFile map;
260 ASSERT_TRUE(map.Initialize(std::move(file), region,
261 MemoryMappedFile::READ_WRITE_EXTEND));
262 EXPECT_EQ(kFileSize + kFileExtend, map.length());
263 ASSERT_TRUE(map.data() != nullptr);
264 EXPECT_TRUE(map.IsValid());
265 ASSERT_TRUE(CheckBufferContents(map.bytes().first<kFileSize>(), 0));
266
267 span<uint8_t> bytes = map.mutable_bytes();
268 EXPECT_EQ(0, bytes[kFileSize + 0]);
269 EXPECT_EQ(0, bytes[kFileSize + 1]);
270 EXPECT_EQ(0, bytes[kFileSize + 2]);
271 bytes[kFileSize + 0] = 'B';
272 bytes[kFileSize + 1] = 'A';
273 bytes[kFileSize + 2] = 'Z';
274 EXPECT_TRUE(CheckBufferContents(map.bytes().first<kFileSize>(), 0));
275 }
276
277 std::optional<int64_t> file_size = GetFileSize(temp_file_path());
278 ASSERT_TRUE(file_size.has_value());
279 EXPECT_LE(static_cast<int64_t>(kFileSize + 3), file_size.value());
280 EXPECT_GE(static_cast<int64_t>(kFileSize + kFileExtend), file_size.value());
281
282 std::string contents;
283 ASSERT_TRUE(ReadFileToString(temp_file_path(), &contents));
284 EXPECT_EQ("BAZ", contents.substr(kFileSize, 3));
285 }
286
287 #if BUILDFLAG(IS_WIN)
TEST_F(MemoryMappedFileTest,ReadCodeImage)288 TEST_F(MemoryMappedFileTest, ReadCodeImage) {
289 base::FilePath exe_path;
290 base::PathService::Get(base::FILE_EXE, &exe_path);
291 File file(exe_path,
292 File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WIN_SHARE_DELETE);
293 ASSERT_TRUE(file.IsValid());
294 MemoryMappedFile map;
295 ASSERT_TRUE(
296 map.Initialize(std::move(file), MemoryMappedFile::READ_CODE_IMAGE));
297 }
298 #endif // BUILDFLAG(IS_WIN)
299
300 } // namespace
301
302 } // namespace base
303