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 <errno.h>
18 #include <linux/fs.h>
19 #include <stdint.h>
20 #include <string.h>
21 #include <sys/mman.h>
22 #include <sys/types.h>
23 #include <unistd.h>
24
25 #include <vector>
26
27 #include <android-base/macros.h>
28 #include <android-base/unique_fd.h>
29 #include <cutils/ashmem.h>
30 #include <gtest/gtest.h>
31
32 using android::base::unique_fd;
33
TestCreateRegion(size_t size,unique_fd & fd,int prot)34 void TestCreateRegion(size_t size, unique_fd &fd, int prot) {
35 fd = unique_fd(ashmem_create_region(nullptr, size));
36 ASSERT_TRUE(fd >= 0);
37 ASSERT_TRUE(ashmem_valid(fd));
38 ASSERT_EQ(size, static_cast<size_t>(ashmem_get_size_region(fd)));
39 ASSERT_EQ(0, ashmem_set_prot_region(fd, prot));
40
41 // We've been inconsistent historically about whether or not these file
42 // descriptors were CLOEXEC. Make sure we're consistent going forward.
43 // https://issuetracker.google.com/165667331
44 ASSERT_EQ(FD_CLOEXEC, (fcntl(fd, F_GETFD) & FD_CLOEXEC));
45 }
46
TestMmap(const unique_fd & fd,size_t size,int prot,void ** region,off_t off=0)47 void TestMmap(const unique_fd& fd, size_t size, int prot, void** region, off_t off = 0) {
48 ASSERT_TRUE(fd >= 0);
49 ASSERT_TRUE(ashmem_valid(fd));
50 *region = mmap(nullptr, size, prot, MAP_SHARED, fd, off);
51 ASSERT_NE(MAP_FAILED, *region);
52 }
53
TestProtDenied(const unique_fd & fd,size_t size,int prot)54 void TestProtDenied(const unique_fd &fd, size_t size, int prot) {
55 ASSERT_TRUE(fd >= 0);
56 ASSERT_TRUE(ashmem_valid(fd));
57 EXPECT_EQ(MAP_FAILED, mmap(nullptr, size, prot, MAP_SHARED, fd, 0));
58 }
59
TestProtIs(const unique_fd & fd,int prot)60 void TestProtIs(const unique_fd& fd, int prot) {
61 ASSERT_TRUE(fd >= 0);
62 ASSERT_TRUE(ashmem_valid(fd));
63 EXPECT_EQ(prot, ioctl(fd, ASHMEM_GET_PROT_MASK));
64 }
65
FillData(std::vector<uint8_t> & data)66 void FillData(std::vector<uint8_t>& data) {
67 for (size_t i = 0; i < data.size(); i++) {
68 data[i] = i & 0xFF;
69 }
70 }
71
TEST(AshmemTest,ForkTest)72 TEST(AshmemTest, ForkTest) {
73 const size_t size = getpagesize();
74 std::vector<uint8_t> data(size);
75 FillData(data);
76
77 unique_fd fd;
78 ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
79
80 void* region1 = nullptr;
81 ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ | PROT_WRITE, ®ion1));
82
83 memcpy(region1, data.data(), size);
84 ASSERT_EQ(0, memcmp(region1, data.data(), size));
85 EXPECT_EQ(0, munmap(region1, size));
86
87 ASSERT_EXIT(
88 {
89 if (!ashmem_valid(fd)) {
90 _exit(3);
91 }
92 void* region2 = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
93 if (region2 == MAP_FAILED) {
94 _exit(1);
95 }
96 if (memcmp(region2, data.data(), size) != 0) {
97 _exit(2);
98 }
99 memset(region2, 0, size);
100 munmap(region2, size);
101 _exit(0);
102 },
103 ::testing::ExitedWithCode(0), "");
104
105 memset(data.data(), 0, size);
106 void *region2;
107 ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ | PROT_WRITE, ®ion2));
108 ASSERT_EQ(0, memcmp(region2, data.data(), size));
109 EXPECT_EQ(0, munmap(region2, size));
110 }
111
TEST(AshmemTest,FileOperationsTest)112 TEST(AshmemTest, FileOperationsTest) {
113 unique_fd fd;
114 void* region = nullptr;
115
116 // Allocate a 4-page buffer, but leave page-sized holes on either side
117 const size_t pageSize = getpagesize();
118 const size_t size = pageSize * 4;
119 const size_t dataSize = pageSize * 2;
120 const size_t holeSize = pageSize;
121 ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
122 ASSERT_NO_FATAL_FAILURE(TestMmap(fd, dataSize, PROT_READ | PROT_WRITE, ®ion, holeSize));
123
124 std::vector<uint8_t> data(dataSize);
125 FillData(data);
126 memcpy(region, data.data(), dataSize);
127
128 const off_t dataStart = holeSize;
129 const off_t dataEnd = dataStart + dataSize;
130
131 // The sequence of seeks below looks something like this:
132 //
133 // [ ][data][data][ ]
134 // --^ lseek(99, SEEK_SET)
135 // ------^ lseek(dataStart, SEEK_CUR)
136 // ------^ lseek(0, SEEK_DATA)
137 // ------------^ lseek(dataStart, SEEK_HOLE)
138 // ^-- lseek(-99, SEEK_END)
139 // ^------ lseek(-dataStart, SEEK_CUR)
140 const struct {
141 // lseek() parameters
142 off_t offset;
143 int whence;
144 // Expected lseek() return value
145 off_t ret;
146 } seeks[] = {
147 {99, SEEK_SET, 99},
148 {dataStart, SEEK_CUR, dataStart + 99},
149 {0, SEEK_DATA, dataStart},
150 {dataStart, SEEK_HOLE, dataEnd},
151 {-99, SEEK_END, static_cast<off_t>(size) - 99},
152 {-dataStart, SEEK_CUR, dataEnd - 99},
153 };
154 for (const auto& cfg : seeks) {
155 errno = 0;
156 ASSERT_TRUE(ashmem_valid(fd));
157 auto off = lseek(fd, cfg.offset, cfg.whence);
158 ASSERT_EQ(cfg.ret, off) << "lseek(" << cfg.offset << ", " << cfg.whence << ") failed"
159 << (errno ? ": " : "") << (errno ? strerror(errno) : "");
160
161 if (off >= dataStart && off < dataEnd) {
162 off_t dataOff = off - dataStart;
163 ssize_t readSize = dataSize - dataOff;
164 uint8_t buf[readSize];
165
166 ASSERT_EQ(readSize, TEMP_FAILURE_RETRY(read(fd, buf, readSize)));
167 EXPECT_EQ(0, memcmp(buf, &data[dataOff], readSize));
168 }
169 }
170
171 EXPECT_EQ(0, munmap(region, dataSize));
172 }
173
TEST(AshmemTest,ProtTest)174 TEST(AshmemTest, ProtTest) {
175 unique_fd fd;
176 const size_t size = getpagesize();
177 void *region;
178
179 ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ));
180 TestProtDenied(fd, size, PROT_WRITE);
181 TestProtIs(fd, PROT_READ);
182 ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_READ, ®ion));
183 EXPECT_EQ(0, munmap(region, size));
184
185 ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_WRITE));
186 TestProtDenied(fd, size, PROT_READ);
187 TestProtIs(fd, PROT_WRITE);
188 ASSERT_NO_FATAL_FAILURE(TestMmap(fd, size, PROT_WRITE, ®ion));
189 EXPECT_EQ(0, munmap(region, size));
190
191 ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
192 TestProtIs(fd, PROT_READ | PROT_WRITE);
193 ASSERT_EQ(0, ashmem_set_prot_region(fd, PROT_READ));
194 errno = 0;
195 ASSERT_EQ(-1, ashmem_set_prot_region(fd, PROT_READ | PROT_WRITE))
196 << "kernel shouldn't allow adding protection bits";
197 EXPECT_EQ(EINVAL, errno);
198 TestProtIs(fd, PROT_READ);
199 TestProtDenied(fd, size, PROT_WRITE);
200 }
201
TEST(AshmemTest,ForkProtTest)202 TEST(AshmemTest, ForkProtTest) {
203 unique_fd fd;
204 const size_t size = getpagesize();
205
206 int protFlags[] = { PROT_READ, PROT_WRITE };
207 for (size_t i = 0; i < arraysize(protFlags); i++) {
208 ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd, PROT_READ | PROT_WRITE));
209 ASSERT_EXIT(
210 {
211 if (!ashmem_valid(fd)) {
212 _exit(3);
213 } else if (ashmem_set_prot_region(fd, protFlags[i]) >= 0) {
214 _exit(0);
215 } else {
216 _exit(1);
217 }
218 },
219 ::testing::ExitedWithCode(0), "");
220 ASSERT_NO_FATAL_FAILURE(TestProtDenied(fd, size, protFlags[1-i]));
221 }
222 }
223
TEST(AshmemTest,ForkMultiRegionTest)224 TEST(AshmemTest, ForkMultiRegionTest) {
225 const size_t size = getpagesize();
226 std::vector<uint8_t> data(size);
227 FillData(data);
228
229 constexpr int nRegions = 16;
230 unique_fd fd[nRegions];
231 for (int i = 0; i < nRegions; i++) {
232 ASSERT_NO_FATAL_FAILURE(TestCreateRegion(size, fd[i], PROT_READ | PROT_WRITE));
233 void* region = nullptr;
234 ASSERT_NO_FATAL_FAILURE(TestMmap(fd[i], size, PROT_READ | PROT_WRITE, ®ion));
235 memcpy(region, data.data(), size);
236 ASSERT_EQ(0, memcmp(region, data.data(), size));
237 EXPECT_EQ(0, munmap(region, size));
238 }
239
240 ASSERT_EXIT({
241 for (int i = 0; i < nRegions; i++) {
242 if (!ashmem_valid(fd[i])) {
243 _exit(3);
244 }
245 void *region = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd[i], 0);
246 if (region == MAP_FAILED) {
247 _exit(1);
248 }
249 if (memcmp(region, data.data(), size) != 0) {
250 munmap(region, size);
251 _exit(2);
252 }
253 memset(region, 0, size);
254 munmap(region, size);
255 }
256 _exit(0);
257 }, ::testing::ExitedWithCode(0), "");
258
259 memset(data.data(), 0, size);
260 for (int i = 0; i < nRegions; i++) {
261 void *region;
262 ASSERT_NO_FATAL_FAILURE(TestMmap(fd[i], size, PROT_READ | PROT_WRITE, ®ion));
263 ASSERT_EQ(0, memcmp(region, data.data(), size));
264 EXPECT_EQ(0, munmap(region, size));
265 }
266 }
267