1 /*
2 * Copyright (C) 2024 HiHope Open Source Organization.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cerrno>
17 #include <cstdio>
18 #include <cstdlib>
19 #include <csignal>
20 #include <string>
21 #include <vector>
22 #include <fcntl.h>
23 #include <unistd.h>
24 #include <malloc.h>
25 #include <arpa/inet.h>
26 #include <gtest/gtest.h>
27 #include <netinet/in.h>
28 #include <sys/stat.h>
29 #include <sys/mman.h>
30 #include <sys/socket.h>
31 #include <sys/types.h>
32 #include "securec.h"
33
34
35 using namespace testing::ext;
36
37 static const char *TEST_FILE = "/data/local/tmp/mmap_test";
38
39 class HatsMadvisecallTest : public testing::Test {
40 public:
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 void SetUp();
44 void TearDown();
45 private:
46 };
SetUp()47 void HatsMadvisecallTest::SetUp()
48 {
49 }
50
TearDown()51 void HatsMadvisecallTest::TearDown()
52 {
53 }
54
SetUpTestCase()55 void HatsMadvisecallTest::SetUpTestCase()
56 {
57 }
58
TearDownTestCase()59 void HatsMadvisecallTest::TearDownTestCase()
60 {
61 unlink(TEST_FILE);
62 }
63
64 /*
65 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0100
66 * @tc.name : MadvisecallForkSuccess_0001
67 * @tc.desc : Madvise sets advise MADV_DOFORK successfully.
68 * @tc.size : MediumTest
69 * @tc.type : Function
70 * @tc.level : Level 1
71 */
72 HWTEST_F(HatsMadvisecallTest, MadvisecallForkSuccess_0001, Function | MediumTest | Level1)
73 {
74 void *ptr;
75 int ret;
76 size_t size = 1024;
77
78 ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
79 EXPECT_NE(ptr, MAP_FAILED);
80
81 ret = madvise(ptr, size, MADV_DOFORK);
82 EXPECT_EQ(ret, 0);
83 munmap(ptr, size);
84 }
85
86 /*
87 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0200
88 * @tc.name : MadvisecallNormalSuccess_0002
89 * @tc.desc : Madvise sets advise MADV_NORMAL successfully.
90 * @tc.size : MediumTest
91 * @tc.type : Function
92 * @tc.level : Level 1
93 */
94 HWTEST_F(HatsMadvisecallTest, MadvisecallNormalSuccess_0002, Function | MediumTest | Level1)
95 {
96 void *ptr;
97 int ret;
98 size_t size = 2048;
99
100 ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
101 EXPECT_NE(ptr, MAP_FAILED);
102
103 ret = madvise(ptr, size, MADV_NORMAL);
104 EXPECT_EQ(ret, 0);
105 munmap(ptr, size);
106 }
107
108 /*
109 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0300
110 * @tc.name : MadvisecallWillneedSuccess_0003
111 * @tc.desc : Madvise sets advise MADV_WILLNEED successfully.
112 * @tc.size : MediumTest
113 * @tc.type : Function
114 * @tc.level : Level 1
115 */
116 HWTEST_F(HatsMadvisecallTest, MadvisecallWillneedSuccess_0003, Function | MediumTest | Level1)
117 {
118 void *ptr;
119 int ret;
120 size_t size = 4096;
121
122 ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
123 EXPECT_NE(ptr, MAP_FAILED);
124
125 ret = madvise(ptr, size, MADV_WILLNEED);
126 EXPECT_EQ(ret, 0);
127 munmap(ptr, size);
128 }
129
130 /*
131 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0400
132 * @tc.name : MadvisecallDontforkSuccess_0004
133 * @tc.desc : Madvise sets advise MADV_DONTFORK successfully.
134 * @tc.size : MediumTest
135 * @tc.type : Function
136 * @tc.level : Level 1
137 */
138 HWTEST_F(HatsMadvisecallTest, MadvisecallDontforkSuccess_0004, Function | MediumTest | Level1)
139 {
140 void *ptr;
141 int ret;
142 size_t size = 1024;
143
144 ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
145 EXPECT_NE(ptr, MAP_FAILED);
146
147 ret = madvise(ptr, size, MADV_DONTFORK);
148 EXPECT_EQ(ret, 0);
149 munmap(ptr, size);
150 }
151
152 /*
153 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0500
154 * @tc.name : MadvisecallSequentialSuccess_0005
155 * @tc.desc : Madvise sets advise MADV_SEQUENTIAL successfully.
156 * @tc.size : MediumTest
157 * @tc.type : Function
158 * @tc.level : Level 1
159 */
160 HWTEST_F(HatsMadvisecallTest, MadvisecallSequentialSuccess_0005, Function | MediumTest | Level1)
161 {
162 void *ptr;
163 int ret;
164 size_t size = 2048;
165
166 ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
167 EXPECT_NE(ptr, MAP_FAILED);
168
169 ret = madvise(ptr, size, MADV_SEQUENTIAL);
170 EXPECT_EQ(ret, 0);
171 munmap(ptr, size);
172 }
173
174 /*
175 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0600
176 * @tc.name : MadvisecallRandomSuccess_0006
177 * @tc.desc : Madvise sets advise MADV_RANDOM successfully.
178 * @tc.size : MediumTest
179 * @tc.type : Function
180 * @tc.level : Level 1
181 */
182 HWTEST_F(HatsMadvisecallTest, MadvisecallRandomSuccess_0006, Function | MediumTest | Level1)
183 {
184 void *ptr;
185 int ret;
186 size_t size = 4096;
187
188 ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
189 EXPECT_NE(ptr, MAP_FAILED);
190
191 ret = madvise(ptr, size, MADV_RANDOM);
192 EXPECT_EQ(ret, 0);
193 munmap(ptr, size);
194 }
195
196 /*
197 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0700
198 * @tc.name : MadvisecallDontneedSuccess_0007
199 * @tc.desc : Madvise sets advise MADV_DONTNEED successfully.
200 * @tc.size : MediumTest
201 * @tc.type : Function
202 * @tc.level : Level 1
203 */
204 HWTEST_F(HatsMadvisecallTest, MadvisecallDontneedSuccess_0007, Function | MediumTest | Level1)
205 {
206 void *ptr;
207 int ret;
208 size_t size = 8192;
209
210 ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
211 EXPECT_NE(ptr, MAP_FAILED);
212
213 ret = madvise(ptr, size, MADV_DONTNEED);
214 EXPECT_EQ(ret, 0);
215 munmap(ptr, size);
216 }
217
218 /*
219 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0800
220 * @tc.name : MadvisecallDontdumpSuccess_0008
221 * @tc.desc : Madvise sets advise MADV_DONTDUMP successfully.
222 * @tc.size : MediumTest
223 * @tc.type : Function
224 * @tc.level : Level 1
225 */
226 HWTEST_F(HatsMadvisecallTest, MadvisecallDontdumpSuccess_0008, Function | MediumTest | Level1)
227 {
228 void *ptr;
229 int ret;
230 size_t size = 1024;
231
232 ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
233 EXPECT_NE(ptr, MAP_FAILED);
234
235 ret = madvise(ptr, size, MADV_DONTDUMP);
236 EXPECT_EQ(ret, 0);
237 munmap(ptr, size);
238 }
239
240 /*
241 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0900
242 * @tc.name : MadvisecallDodumpSuccess_0009
243 * @tc.desc : Madvise sets advise MADV_DODUMP successfully.
244 * @tc.size : MediumTest
245 * @tc.type : Function
246 * @tc.level : Level 1
247 */
248 HWTEST_F(HatsMadvisecallTest, MadvisecallDodumpSuccess_0009, Function | MediumTest | Level1)
249 {
250 void *ptr;
251 int ret;
252 size_t size = 2048;
253
254 ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
255 EXPECT_NE(ptr, MAP_FAILED);
256
257 ret = madvise(ptr, size, MADV_DODUMP);
258 EXPECT_EQ(ret, 0);
259 munmap(ptr, size);
260 }
261
262 /*
263 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_1000
264 * @tc.name : MadvisecallRemoveSuccess_0010
265 * @tc.desc : Madvise sets advise MADV_REMOVE successfully.
266 * @tc.size : MediumTest
267 * @tc.type : Function
268 * @tc.level : Level 1
269 */
270 HWTEST_F(HatsMadvisecallTest, MadvisecallRemoveSuccess_0010, Function | MediumTest | Level1)
271 {
272 void *ptr;
273 int ret;
274 size_t size = 2048;
275
276 int fd = open(TEST_FILE, O_CREAT | O_RDWR, 0664);
277
278 ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
279 EXPECT_NE(ptr, MAP_FAILED);
280
281 ret = madvise(ptr, size, MADV_REMOVE);
282 EXPECT_EQ(ret, 0);
283
284 ret = munmap(ptr, size);
285 EXPECT_EQ(ret, 0);
286 close(fd);
287 }