1 /*
2 * Copyright (C) 2012 Linux Test Project, Inc.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of version 2 of the GNU General Public
6 * License as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it would be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11 *
12 * Further, this software is distributed without any warranty that it
13 * is free of the rightful claim of any third person regarding
14 * infringement or the like. Any license provided herein, whether
15 * implied or otherwise, applies only to this software file. Patent
16 * licenses, if any, provided herein do not apply to combinations of
17 * this program with other software, or any other product whatsoever.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22 * 02110-1301, USA.
23 */
24
25 /*
26 * errno tests shared by process_vm_readv, process_vm_writev tests.
27 */
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <sys/syscall.h>
31 #include <sys/uio.h>
32 #include <sys/wait.h>
33 #include <sys/mman.h>
34 #include <errno.h>
35 #include <signal.h>
36 #include <stdio.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <unistd.h>
40 #include <limits.h>
41 #include <pwd.h>
42 #include "config.h"
43 #include "test.h"
44 #include "safe_macros.h"
45 #include "lapi/syscalls.h"
46
47 struct process_vm_params {
48 int len;
49 char *ldummy;
50 char *rdummy;
51 pid_t pid;
52 struct iovec *lvec;
53 unsigned long liovcnt;
54 struct iovec *rvec;
55 unsigned long riovcnt;
56 unsigned long flags;
57 };
58
59 static int rflag;
60 static int wflag;
61
62 static option_t options[] = {
63 {"r", &rflag, NULL},
64 {"w", &wflag, NULL},
65 {NULL, NULL, NULL}
66 };
67
68 static char TCID_readv[] = "process_vm_readv";
69 static char TCID_writev[] = "process_vm_writev";
70 char *TCID = "cma01";
71 int TST_TOTAL = 1;
72 static void (*cma_test_params) (struct process_vm_params * params) = NULL;
73
74 static void setup(char *argv[]);
75 static void cleanup(void);
76 static void help(void);
77
78 static void cma_test_params_read(struct process_vm_params *params);
79 static void cma_test_params_write(struct process_vm_params *params);
80 static void cma_test_errnos(void);
81
main(int argc,char * argv[])82 int main(int argc, char *argv[])
83 {
84 int lc;
85
86 tst_parse_opts(argc, argv, options, &help);
87
88 setup(argv);
89 for (lc = 0; TEST_LOOPING(lc); lc++) {
90 tst_count = 0;
91 cma_test_errnos();
92 }
93 cleanup();
94 tst_exit();
95 }
96
setup(char * argv[])97 static void setup(char *argv[])
98 {
99 tst_require_root();
100
101 if (rflag && wflag)
102 tst_brkm(TBROK, NULL, "Parameters -r -w can not be used"
103 " at the same time.");
104 else if (rflag) {
105 TCID = TCID_readv;
106 cma_test_params = cma_test_params_read;
107 } else if (wflag) {
108 TCID = TCID_writev;
109 cma_test_params = cma_test_params_write;
110 } else
111 tst_brkm(TBROK, NULL, "Parameter missing, required -r or -w.");
112 TEST_PAUSE;
113 }
114
cleanup(void)115 static void cleanup(void)
116 {
117 }
118
help(void)119 static void help(void)
120 {
121 printf(" -r Use process_vm_readv\n");
122 printf(" -w Use process_vm_writev\n");
123 }
124
cma_test_params_read(struct process_vm_params * params)125 static void cma_test_params_read(struct process_vm_params *params)
126 {
127 TEST(ltp_syscall(__NR_process_vm_readv,
128 params->pid,
129 params->lvec, params->liovcnt,
130 params->rvec, params->riovcnt,
131 params->flags));
132 }
133
cma_test_params_write(struct process_vm_params * params)134 static void cma_test_params_write(struct process_vm_params *params)
135 {
136 TEST(ltp_syscall(__NR_process_vm_writev,
137 params->pid,
138 params->lvec, params->liovcnt,
139 params->rvec, params->riovcnt,
140 params->flags));
141 }
142
cma_check_ret(long expected_ret,long act_ret)143 static int cma_check_ret(long expected_ret, long act_ret)
144 {
145 if (expected_ret == act_ret) {
146 tst_resm(TPASS, "expected ret success - "
147 "returned value = %ld", act_ret);
148 } else {
149 tst_resm(TFAIL, "unexpected failure - "
150 "returned value = %ld, expected: %ld",
151 act_ret, expected_ret);
152 return 1;
153 }
154 return 0;
155 }
156
cma_check_errno(long expected_errno)157 static int cma_check_errno(long expected_errno)
158 {
159 if (TEST_ERRNO == expected_errno)
160 tst_resm(TPASS | TTERRNO, "expected failure");
161 else if (TEST_ERRNO == 0) {
162 tst_resm(TFAIL, "call succeeded unexpectedly");
163 return 1;
164 } else {
165 tst_resm(TFAIL | TTERRNO, "unexpected failure - "
166 "expected = %ld : %s, actual",
167 expected_errno, strerror(expected_errno));
168 return 2;
169 }
170 return 0;
171 }
172
cma_alloc_sane_params(void)173 static struct process_vm_params *cma_alloc_sane_params(void)
174 {
175 struct process_vm_params *sane_params;
176 int len;
177
178 len = getpagesize();
179 sane_params = SAFE_MALLOC(NULL, sizeof(struct process_vm_params));
180 sane_params->len = len;
181 sane_params->ldummy = SAFE_MALLOC(NULL, len);
182 sane_params->rdummy = SAFE_MALLOC(NULL, len);
183
184 sane_params->lvec = SAFE_MALLOC(NULL, sizeof(struct iovec));
185 sane_params->lvec->iov_base = sane_params->ldummy;
186 sane_params->lvec->iov_len = len;
187 sane_params->liovcnt = 1;
188
189 sane_params->rvec = SAFE_MALLOC(NULL, sizeof(struct iovec));
190 sane_params->rvec->iov_base = sane_params->rdummy;
191 sane_params->rvec->iov_len = len;
192 sane_params->riovcnt = 1;
193
194 sane_params->flags = 0;
195 sane_params->pid = getpid();
196
197 return sane_params;
198 }
199
cma_free_params(struct process_vm_params * params)200 static void cma_free_params(struct process_vm_params *params)
201 {
202 if (params) {
203 free(params->ldummy);
204 free(params->rdummy);
205 free(params->lvec);
206 free(params->rvec);
207 free(params);
208 }
209 }
210
cma_test_sane_params(void)211 static void cma_test_sane_params(void)
212 {
213 struct process_vm_params *sane_params;
214
215 sane_params = cma_alloc_sane_params();
216 tst_resm(TINFO, "test_sane_params");
217 cma_test_params(sane_params);
218 cma_check_ret(sane_params->len, TEST_RETURN);
219 cma_free_params(sane_params);
220 }
221
cma_test_flags(void)222 static void cma_test_flags(void)
223 {
224 struct process_vm_params *params;
225 long flags[] = { -INT_MAX, -1, 1, INT_MAX, 0 };
226 int flags_size = sizeof(flags) / sizeof(flags[0]);
227 int i;
228
229 params = cma_alloc_sane_params();
230 for (i = 0; i < flags_size; i++) {
231 params->flags = flags[i];
232 tst_resm(TINFO, "test_flags, flags=%ld", flags[i]);
233 cma_test_params(params);
234 /* atm. only flags == 0 is allowed, everything else
235 * should fail with EINVAL */
236 if (flags[i] != 0) {
237 cma_check_ret(-1, TEST_RETURN);
238 cma_check_errno(EINVAL);
239 } else {
240 cma_check_ret(params->len, TEST_RETURN);
241 }
242 }
243 cma_free_params(params);
244 }
245
cma_test_iov_len_overflow(void)246 static void cma_test_iov_len_overflow(void)
247 {
248 struct process_vm_params *params;
249 ssize_t maxlen = -1;
250 params = cma_alloc_sane_params();
251
252 params->lvec->iov_len = maxlen;
253 params->rvec->iov_len = maxlen;
254 tst_resm(TINFO, "test_iov_len_overflow");
255 cma_test_params(params);
256 cma_check_ret(-1, TEST_RETURN);
257 cma_check_errno(EINVAL);
258 cma_free_params(params);
259 }
260
cma_test_iov_invalid(void)261 static void cma_test_iov_invalid(void)
262 {
263 struct process_vm_params *sane_params;
264 struct process_vm_params params_copy;
265
266 sane_params = cma_alloc_sane_params();
267 /* make a shallow copy we can 'damage' */
268
269 params_copy = *sane_params;
270 tst_resm(TINFO, "test_iov_invalid - lvec->iov_base");
271 params_copy.lvec->iov_base = (void *)-1;
272 cma_test_params(¶ms_copy);
273 cma_check_ret(-1, TEST_RETURN);
274 cma_check_errno(EFAULT);
275
276 params_copy = *sane_params;
277 tst_resm(TINFO, "test_iov_invalid - rvec->iov_base");
278 params_copy.rvec->iov_base = (void *)-1;
279 cma_test_params(¶ms_copy);
280 cma_check_ret(-1, TEST_RETURN);
281 cma_check_errno(EFAULT);
282
283 params_copy = *sane_params;
284 tst_resm(TINFO, "test_iov_invalid - lvec");
285 params_copy.lvec = (void *)-1;
286 cma_test_params(¶ms_copy);
287 cma_check_ret(-1, TEST_RETURN);
288 cma_check_errno(EFAULT);
289
290 params_copy = *sane_params;
291 tst_resm(TINFO, "test_iov_invalid - rvec");
292 params_copy.rvec = (void *)-1;
293 cma_test_params(¶ms_copy);
294 cma_check_ret(-1, TEST_RETURN);
295 cma_check_errno(EFAULT);
296
297 cma_free_params(sane_params);
298 }
299
cma_test_invalid_pid(void)300 static void cma_test_invalid_pid(void)
301 {
302 pid_t invalid_pid = -1;
303 struct process_vm_params *params;
304
305 params = cma_alloc_sane_params();
306 tst_resm(TINFO, "test_invalid_pid");
307 params->pid = invalid_pid;
308 cma_test_params(params);
309 cma_check_ret(-1, TEST_RETURN);
310 cma_check_errno(ESRCH);
311 cma_free_params(params);
312
313 invalid_pid = tst_get_unused_pid(cleanup);
314
315 params = cma_alloc_sane_params();
316 params->pid = invalid_pid;
317 cma_test_params(params);
318 cma_check_ret(-1, TEST_RETURN);
319 cma_check_errno(ESRCH);
320 cma_free_params(params);
321 }
322
cma_test_invalid_perm(void)323 static void cma_test_invalid_perm(void)
324 {
325 char nobody_uid[] = "nobody";
326 struct passwd *ltpuser;
327 int status;
328 struct process_vm_params *params;
329 pid_t child_pid;
330 pid_t parent_pid;
331 int ret = 0;
332
333 tst_resm(TINFO, "test_invalid_perm");
334 parent_pid = getpid();
335 child_pid = fork();
336 switch (child_pid) {
337 case -1:
338 tst_brkm(TBROK | TERRNO, cleanup, "fork");
339 break;
340 case 0:
341 ltpuser = getpwnam(nobody_uid);
342 if (ltpuser == NULL)
343 tst_brkm(TBROK | TERRNO, NULL, "getpwnam failed");
344 SAFE_SETUID(NULL, ltpuser->pw_uid);
345
346 params = cma_alloc_sane_params();
347 params->pid = parent_pid;
348 cma_test_params(params);
349 ret |= cma_check_ret(-1, TEST_RETURN);
350 ret |= cma_check_errno(EPERM);
351 cma_free_params(params);
352 exit(ret);
353 default:
354 SAFE_WAITPID(cleanup, child_pid, &status, 0);
355 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
356 tst_resm(TFAIL, "child returns %d", status);
357 }
358 }
359
cma_test_invalid_protection(void)360 static void cma_test_invalid_protection(void)
361 {
362 struct process_vm_params *sane_params;
363 struct process_vm_params params_copy;
364 void *p;
365
366 sane_params = cma_alloc_sane_params();
367 /* make a shallow copy we can 'damage' */
368
369 p = mmap(NULL, getpagesize(), PROT_NONE,
370 MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
371 if (p == MAP_FAILED)
372 tst_brkm(TBROK | TERRNO, cleanup, "mmap");
373
374 params_copy = *sane_params;
375 params_copy.lvec->iov_base = p;
376 tst_resm(TINFO, "test_invalid_protection lvec");
377 cma_test_params(¶ms_copy);
378 cma_check_ret(-1, TEST_RETURN);
379 cma_check_errno(EFAULT);
380
381 params_copy = *sane_params;
382 params_copy.rvec->iov_base = p;
383 tst_resm(TINFO, "test_invalid_protection rvec");
384 cma_test_params(¶ms_copy);
385 cma_check_ret(-1, TEST_RETURN);
386 cma_check_errno(EFAULT);
387
388 SAFE_MUNMAP(cleanup, p, getpagesize());
389
390 cma_free_params(sane_params);
391 }
392
cma_test_errnos(void)393 static void cma_test_errnos(void)
394 {
395 cma_test_sane_params();
396 cma_test_flags();
397 cma_test_iov_len_overflow();
398 cma_test_iov_invalid();
399 cma_test_invalid_pid();
400 cma_test_invalid_perm();
401 cma_test_invalid_protection();
402 }
403