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
35using namespace testing::ext;
36
37static const char *TEST_FILE = "/data/local/tmp/mmap_test";
38
39class HatsMadvisecallTest : public testing::Test {
40public:
41    static void SetUpTestCase();
42    static void TearDownTestCase();
43    void SetUp();
44    void TearDown();
45private:
46};
47void HatsMadvisecallTest::SetUp()
48{
49}
50
51void HatsMadvisecallTest::TearDown()
52{
53}
54
55void HatsMadvisecallTest::SetUpTestCase()
56{
57}
58
59void HatsMadvisecallTest::TearDownTestCase()
60{
61}
62
63/*
64 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0100
65 * @tc.name   : MadvisecallForkSuccess_0001
66 * @tc.desc   : Madvise sets advise MADV_DOFORK successfully.
67 * @tc.size   : MediumTest
68 * @tc.type   : Function
69 * @tc.level  : Level 1
70 */
71HWTEST_F(HatsMadvisecallTest, MadvisecallForkSuccess_0001, Function | MediumTest | Level1)
72{
73    void *ptr;
74    int ret;
75    size_t size = 1024;
76
77    ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
78    EXPECT_NE(ptr, MAP_FAILED);
79
80    ret = madvise(ptr, size, MADV_DOFORK);
81    EXPECT_EQ(ret, 0);
82    munmap(ptr, size);
83}
84
85/*
86 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0200
87 * @tc.name   : MadvisecallNormalSuccess_0002
88 * @tc.desc   : Madvise sets advise MADV_NORMAL successfully.
89 * @tc.size   : MediumTest
90 * @tc.type   : Function
91 * @tc.level  : Level 1
92 */
93HWTEST_F(HatsMadvisecallTest, MadvisecallNormalSuccess_0002, Function | MediumTest | Level1)
94{
95    void *ptr;
96    int ret;
97    size_t size = 2048;
98
99    ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
100    EXPECT_NE(ptr, MAP_FAILED);
101
102    ret = madvise(ptr, size, MADV_NORMAL);
103    EXPECT_EQ(ret, 0);
104    munmap(ptr, size);
105}
106
107/*
108 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0300
109 * @tc.name   : MadvisecallWillneedSuccess_0003
110 * @tc.desc   : Madvise sets advise MADV_WILLNEED successfully.
111 * @tc.size   : MediumTest
112 * @tc.type   : Function
113 * @tc.level  : Level 1
114 */
115HWTEST_F(HatsMadvisecallTest, MadvisecallWillneedSuccess_0003, Function | MediumTest | Level1)
116{
117    void *ptr;
118    int ret;
119    size_t size = 4096;
120
121    ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
122    EXPECT_NE(ptr, MAP_FAILED);
123
124    ret = madvise(ptr, size, MADV_WILLNEED);
125    EXPECT_EQ(ret, 0);
126    munmap(ptr, size);
127}
128
129/*
130 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0400
131 * @tc.name   : MadvisecallDontforkSuccess_0004
132 * @tc.desc   : Madvise sets advise MADV_DONTFORK successfully.
133 * @tc.size   : MediumTest
134 * @tc.type   : Function
135 * @tc.level  : Level 1
136 */
137HWTEST_F(HatsMadvisecallTest, MadvisecallDontforkSuccess_0004, Function | MediumTest | Level1)
138{
139    void *ptr;
140    int ret;
141    size_t size = 1024;
142
143    ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
144    EXPECT_NE(ptr, MAP_FAILED);
145
146    ret = madvise(ptr, size, MADV_DONTFORK);
147    EXPECT_EQ(ret, 0);
148    munmap(ptr, size);
149}
150
151/*
152 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0500
153 * @tc.name   : MadvisecallSequentialSuccess_0005
154 * @tc.desc   : Madvise sets advise MADV_SEQUENTIAL successfully.
155 * @tc.size   : MediumTest
156 * @tc.type   : Function
157 * @tc.level  : Level 1
158 */
159HWTEST_F(HatsMadvisecallTest, MadvisecallSequentialSuccess_0005, Function | MediumTest | Level1)
160{
161    void *ptr;
162    int ret;
163    size_t size = 2048;
164
165    ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
166    EXPECT_NE(ptr, MAP_FAILED);
167
168    ret = madvise(ptr, size, MADV_SEQUENTIAL);
169    EXPECT_EQ(ret, 0);
170    munmap(ptr, size);
171}
172
173/*
174 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0600
175 * @tc.name   : MadvisecallRandomSuccess_0006
176 * @tc.desc   : Madvise sets advise MADV_RANDOM successfully.
177 * @tc.size   : MediumTest
178 * @tc.type   : Function
179 * @tc.level  : Level 1
180 */
181HWTEST_F(HatsMadvisecallTest, MadvisecallRandomSuccess_0006, Function | MediumTest | Level1)
182{
183    void *ptr;
184    int ret;
185    size_t size = 4096;
186
187    ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
188    EXPECT_NE(ptr, MAP_FAILED);
189
190    ret = madvise(ptr, size, MADV_RANDOM);
191    EXPECT_EQ(ret, 0);
192    munmap(ptr, size);
193}
194
195/*
196 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0700
197 * @tc.name   : MadvisecallDontneedSuccess_0007
198 * @tc.desc   : Madvise sets advise MADV_DONTNEED successfully.
199 * @tc.size   : MediumTest
200 * @tc.type   : Function
201 * @tc.level  : Level 1
202 */
203HWTEST_F(HatsMadvisecallTest, MadvisecallDontneedSuccess_0007, Function | MediumTest | Level1)
204{
205    void *ptr;
206    int ret;
207    size_t size = 8192;
208
209    ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
210    EXPECT_NE(ptr, MAP_FAILED);
211
212    ret = madvise(ptr, size, MADV_DONTNEED);
213    EXPECT_EQ(ret, 0);
214    munmap(ptr, size);
215}
216
217/*
218 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0800
219 * @tc.name   : MadvisecallDontdumpSuccess_0008
220 * @tc.desc   : Madvise sets advise MADV_DONTDUMP successfully.
221 * @tc.size   : MediumTest
222 * @tc.type   : Function
223 * @tc.level  : Level 1
224 */
225HWTEST_F(HatsMadvisecallTest, MadvisecallDontdumpSuccess_0008, Function | MediumTest | Level1)
226{
227    void *ptr;
228    int ret;
229    size_t size = 1024;
230
231    ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
232    EXPECT_NE(ptr, MAP_FAILED);
233
234    ret = madvise(ptr, size, MADV_DONTDUMP);
235    EXPECT_EQ(ret, 0);
236    munmap(ptr, size);
237}
238
239/*
240 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_0900
241 * @tc.name   : MadvisecallDodumpSuccess_0009
242 * @tc.desc   : Madvise sets advise MADV_DODUMP successfully.
243 * @tc.size   : MediumTest
244 * @tc.type   : Function
245 * @tc.level  : Level 1
246 */
247HWTEST_F(HatsMadvisecallTest, MadvisecallDodumpSuccess_0009, Function | MediumTest | Level1)
248{
249    void *ptr;
250    int ret;
251    size_t size = 2048;
252
253    ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
254    EXPECT_NE(ptr, MAP_FAILED);
255
256    ret = madvise(ptr, size, MADV_DODUMP);
257    EXPECT_EQ(ret, 0);
258    munmap(ptr, size);
259}
260
261/*
262 * @tc.number : SUB_KERNEL_SYSCALL_MADVISECALL_1000
263 * @tc.name   : MadvisecallRemoveSuccess_0010
264 * @tc.desc   : Madvise sets advise MADV_REMOVE successfully.
265 * @tc.size   : MediumTest
266 * @tc.type   : Function
267 * @tc.level  : Level 1
268 */
269HWTEST_F(HatsMadvisecallTest, MadvisecallRemoveSuccess_0010, Function | MediumTest | Level1)
270{
271    void *ptr;
272    int ret;
273    size_t size = 2048;
274
275    int fd = open(TEST_FILE, O_CREAT | O_RDWR, 0664);
276
277    ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
278    EXPECT_NE(ptr, MAP_FAILED);
279
280    ret = madvise(ptr, size, MADV_REMOVE);
281    EXPECT_EQ(ret, 0);
282
283    ret = munmap(ptr, size);
284    EXPECT_EQ(ret, 0);
285    close(fd);
286}