1 /*
2 * Copyright (c) International Business Machines Corp., 2001
3 * Author: Rajeev Tiwari: rajeevti@in.ibm.com
4 * Copyright (c) 2004 Gernot Payer <gpayer@suse.de>
5 * Copyright (c) 2013 Cyril Hrubis <chrubis@suse.cz>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 /*
23 * test1:
24 * Invoke mincore() when the start address is not multiple of page size.
25 * EINVAL
26 * test2:
27 * Invoke mincore() when the vector points to an invalid address. EFAULT
28 * test3:
29 * Invoke mincore() when the starting address + length contained unmapped
30 * memory. ENOMEM
31 * test4:
32 * Invoke mincore() when length is greater than (TASK_SIZE - addr). ENOMEM
33 * In Linux 2.6.11 and earlier, the error EINVAL was returned for this
34 * condition.
35 */
36
37 #include <fcntl.h>
38 #include <errno.h>
39 #include <sys/mman.h>
40 #include <stdlib.h>
41 #include <unistd.h>
42 #include <sys/resource.h>
43 #include <sys/types.h>
44 #include <sys/stat.h>
45 #include "test.h"
46 #include "safe_macros.h"
47
48 static int pagesize;
49 static rlim_t STACK_LIMIT = 10485760;
50
51 static void cleanup(void);
52 static void setup(void);
53
54 char *TCID = "mincore01";
55
56 static char *global_pointer;
57 static unsigned char *global_vec;
58 static int global_len;
59
60 struct test_case_t;
61 static void setup1(struct test_case_t *tc);
62 static void setup2(struct test_case_t *tc);
63 static void setup3(struct test_case_t *tc);
64 static void setup4(struct test_case_t *tc);
65
66 static struct test_case_t {
67 char *addr;
68 size_t len;
69 unsigned char *vector;
70 int exp_errno;
71 void (*setupfunc) (struct test_case_t *tc);
72 } TC[] = {
73 {NULL, 0, NULL, EINVAL, setup1},
74 {NULL, 0, NULL, EFAULT, setup2},
75 {NULL, 0, NULL, ENOMEM, setup3},
76 {NULL, 0, NULL, ENOMEM, setup4}
77 };
78
79 static void mincore_verify(struct test_case_t *tc);
80
81 int TST_TOTAL = ARRAY_SIZE(TC);
82
main(int ac,char ** av)83 int main(int ac, char **av)
84 {
85 int i, lc;
86
87 tst_parse_opts(ac, av, NULL, NULL);
88
89 setup();
90
91 for (lc = 0; TEST_LOOPING(lc); lc++) {
92 tst_count = 0;
93
94 for (i = 0; i < TST_TOTAL; i++)
95 mincore_verify(&TC[i]);
96 }
97
98 cleanup();
99 tst_exit();
100 }
101
setup1(struct test_case_t * tc)102 static void setup1(struct test_case_t *tc)
103 {
104 tc->addr = global_pointer + 1;
105 tc->len = global_len;
106 tc->vector = global_vec;
107 }
108
setup2(struct test_case_t * tc)109 void setup2(struct test_case_t *tc)
110 {
111 unsigned char *t;
112 struct rlimit limit;
113
114 t = SAFE_MMAP(cleanup, NULL, global_len, PROT_READ | PROT_WRITE,
115 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
116
117 SAFE_MUNMAP(cleanup, t, global_len);
118
119 /* set stack limit so that the unmaped pointer is invalid for architectures like s390 */
120 limit.rlim_cur = STACK_LIMIT;
121 limit.rlim_max = STACK_LIMIT;
122
123 if (setrlimit(RLIMIT_STACK, &limit) != 0)
124 tst_brkm(TBROK | TERRNO, cleanup, "setrlimit failed");
125
126 tc->addr = global_pointer;
127 tc->len = global_len;
128 tc->vector = t;
129 }
130
setup3(struct test_case_t * tc)131 static void setup3(struct test_case_t *tc)
132 {
133 tc->addr = global_pointer;
134 tc->len = global_len * 2;
135 SAFE_MUNMAP(cleanup, global_pointer + global_len, global_len);
136 tc->vector = global_vec;
137 }
138
setup4(struct test_case_t * tc)139 static void setup4(struct test_case_t *tc)
140 {
141 struct rlimit as_lim;
142
143 SAFE_GETRLIMIT(cleanup, RLIMIT_AS, &as_lim);
144
145 tc->addr = global_pointer;
146 tc->len = as_lim.rlim_cur - (rlim_t)global_pointer + pagesize;
147 tc->vector = global_vec;
148
149 /*
150 * In linux 2.6.11 and earlier, EINVAL was returned for this condition.
151 */
152 if (tst_kvercmp(2, 6, 11) <= 0)
153 tc->exp_errno = EINVAL;
154 }
155
setup(void)156 static void setup(void)
157 {
158 char *buf;
159 int fd;
160
161 pagesize = getpagesize();
162
163 tst_sig(NOFORK, DEF_HANDLER, cleanup);
164
165 tst_tmpdir();
166
167 TEST_PAUSE;
168
169 /* global_pointer will point to a mmapped area of global_len bytes */
170 global_len = pagesize * 2;
171
172 buf = SAFE_MALLOC(cleanup, global_len);
173 memset(buf, 42, global_len);
174
175 fd = SAFE_OPEN(cleanup, "mincore01", O_CREAT | O_RDWR,
176 S_IRUSR | S_IWUSR);
177
178 SAFE_WRITE(cleanup, 1, fd, buf, global_len);
179
180 free(buf);
181
182 global_pointer = SAFE_MMAP(cleanup, NULL, global_len * 2,
183 PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
184
185 global_vec = SAFE_MALLOC(cleanup,
186 (global_len + pagesize - 1) / pagesize);
187
188 SAFE_CLOSE(cleanup, fd);
189 }
190
mincore_verify(struct test_case_t * tc)191 static void mincore_verify(struct test_case_t *tc)
192 {
193 if (tc->setupfunc)
194 tc->setupfunc(tc);
195
196 TEST(mincore(tc->addr, tc->len, tc->vector));
197
198 if (TEST_RETURN != -1) {
199 tst_resm(TFAIL, "succeeded unexpectedly");
200 return;
201 }
202
203 if (TEST_ERRNO == tc->exp_errno) {
204 tst_resm(TPASS | TTERRNO, "failed as expected");
205 } else {
206 tst_resm(TFAIL | TTERRNO,
207 "mincore failed unexpectedly; expected: "
208 "%d - %s", tc->exp_errno,
209 strerror(tc->exp_errno));
210 }
211 }
212
cleanup(void)213 static void cleanup(void)
214 {
215 free(global_vec);
216
217 if (munmap(global_pointer, global_len) == -1)
218 tst_resm(TWARN | TERRNO, "munmap failed");
219
220 tst_rmdir();
221 }
222