* [LTP] [PATCH v1] Rewrite process_vm01 test using new LTP API
@ 2022-08-24 12:40 Andrea Cervesato via ltp
2022-08-26 7:04 ` Richard Palethorpe
0 siblings, 1 reply; 7+ messages in thread
From: Andrea Cervesato via ltp @ 2022-08-24 12:40 UTC (permalink / raw)
To: ltp
Now test is run on process_vm_writev by default and process_vm_readv can
be selected by passing -r command line option.
Signed-off-by: Andrea Cervesato <andrea.cervesato@suse.com>
---
runtest/syscalls | 2 +-
testcases/kernel/syscalls/cma/process_vm01.c | 464 ++++++++-----------
2 files changed, 188 insertions(+), 278 deletions(-)
diff --git a/runtest/syscalls b/runtest/syscalls
index 3847e8af2..70f22fbd5 100644
--- a/runtest/syscalls
+++ b/runtest/syscalls
@@ -1031,7 +1031,7 @@ profil01 profil01
process_vm_readv01 process_vm01 -r
process_vm_readv02 process_vm_readv02
process_vm_readv03 process_vm_readv03
-process_vm_writev01 process_vm01 -w
+process_vm_writev01 process_vm01
process_vm_writev02 process_vm_writev02
prot_hsymlinks prot_hsymlinks
diff --git a/testcases/kernel/syscalls/cma/process_vm01.c b/testcases/kernel/syscalls/cma/process_vm01.c
index 16f14d66b..bfd5c5acb 100644
--- a/testcases/kernel/syscalls/cma/process_vm01.c
+++ b/testcases/kernel/syscalls/cma/process_vm01.c
@@ -1,47 +1,18 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
/*
- * Copyright (C) 2012 Linux Test Project, Inc.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU General Public
- * License as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it would be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * Further, this software is distributed without any warranty that it
- * is free of the rightful claim of any third person regarding
- * infringement or the like. Any license provided herein, whether
- * implied or otherwise, applies only to this software file. Patent
- * licenses, if any, provided herein do not apply to combinations of
- * this program with other software, or any other product whatsoever.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
+ * Copyright (c) Linux Test Project, 2012
+ * Copyright (C) 2021 SUSE LLC Andrea Cervesato <andrea.cervesato@suse.com>
*/
-/*
- * errno tests shared by process_vm_readv, process_vm_writev tests.
+/*\
+ * [Description]
+ *
+ * Test errno codes in process_vm_readv and process_vm_writev syscalls.
*/
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/syscall.h>
-#include <sys/uio.h>
-#include <sys/wait.h>
-#include <sys/mman.h>
-#include <errno.h>
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <limits.h>
+
#include <pwd.h>
-#include "config.h"
-#include "test.h"
-#include "safe_macros.h"
+#include <stdlib.h>
+#include "tst_test.h"
#include "lapi/syscalls.h"
struct process_vm_params {
@@ -56,137 +27,27 @@ struct process_vm_params {
unsigned long flags;
};
-static int rflag;
-static int wflag;
-
-static option_t options[] = {
- {"r", &rflag, NULL},
- {"w", &wflag, NULL},
- {NULL, NULL, NULL}
-};
-
-static char TCID_readv[] = "process_vm_readv";
-static char TCID_writev[] = "process_vm_writev";
-char *TCID = "cma01";
-int TST_TOTAL = 1;
-static void (*cma_test_params) (struct process_vm_params * params) = NULL;
-
-static void setup(char *argv[]);
-static void cleanup(void);
-static void help(void);
-
-static void cma_test_params_read(struct process_vm_params *params);
-static void cma_test_params_write(struct process_vm_params *params);
-static void cma_test_errnos(void);
-
-int main(int argc, char *argv[])
-{
- int lc;
-
- tst_parse_opts(argc, argv, options, &help);
-
- setup(argv);
- for (lc = 0; TEST_LOOPING(lc); lc++) {
- tst_count = 0;
- cma_test_errnos();
- }
- cleanup();
- tst_exit();
-}
-
-static void setup(char *argv[])
-{
- tst_require_root();
-
- if (rflag && wflag)
- tst_brkm(TBROK, NULL, "Parameters -r -w can not be used"
- " at the same time.");
- else if (rflag) {
- TCID = TCID_readv;
- cma_test_params = cma_test_params_read;
- } else if (wflag) {
- TCID = TCID_writev;
- cma_test_params = cma_test_params_write;
- } else
- tst_brkm(TBROK, NULL, "Parameter missing, required -r or -w.");
- TEST_PAUSE;
-}
-
-static void cleanup(void)
-{
-}
-
-static void help(void)
-{
- printf(" -r Use process_vm_readv\n");
- printf(" -w Use process_vm_writev\n");
-}
-
-static void cma_test_params_read(struct process_vm_params *params)
-{
- TEST(tst_syscall(__NR_process_vm_readv,
- params->pid,
- params->lvec, params->liovcnt,
- params->rvec, params->riovcnt,
- params->flags));
-}
-
-static void cma_test_params_write(struct process_vm_params *params)
-{
- TEST(tst_syscall(__NR_process_vm_writev,
- params->pid,
- params->lvec, params->liovcnt,
- params->rvec, params->riovcnt,
- params->flags));
-}
-
-static int cma_check_ret(long expected_ret, long act_ret)
-{
- if (expected_ret == act_ret) {
- tst_resm(TPASS, "expected ret success - "
- "returned value = %ld", act_ret);
- } else {
- tst_resm(TFAIL, "unexpected failure - "
- "returned value = %ld, expected: %ld",
- act_ret, expected_ret);
- return 1;
- }
- return 0;
-}
-
-static int cma_check_errno(long expected_errno)
-{
- if (TEST_ERRNO == expected_errno)
- tst_resm(TPASS | TTERRNO, "expected failure");
- else if (TEST_ERRNO == 0) {
- tst_resm(TFAIL, "call succeeded unexpectedly");
- return 1;
- } else {
- tst_resm(TFAIL | TTERRNO, "unexpected failure - "
- "expected = %ld : %s, actual",
- expected_errno, strerror(expected_errno));
- return 2;
- }
- return 0;
-}
+static char *str_read;
+static void (*test_params)(struct process_vm_params *params);
-static struct process_vm_params *cma_alloc_sane_params(void)
+static struct process_vm_params *alloc_params(void)
{
struct process_vm_params *sane_params;
int len;
len = getpagesize();
- sane_params = SAFE_MALLOC(NULL, sizeof(struct process_vm_params));
+
+ sane_params = SAFE_MALLOC(sizeof(struct process_vm_params));
sane_params->len = len;
- sane_params->ldummy = SAFE_MALLOC(NULL, len);
- sane_params->rdummy = SAFE_MALLOC(NULL, len);
+ sane_params->ldummy = SAFE_MALLOC(len);
+ sane_params->rdummy = SAFE_MALLOC(len);
- sane_params->lvec = SAFE_MALLOC(NULL, sizeof(struct iovec));
+ sane_params->lvec = SAFE_MALLOC(sizeof(struct process_vm_params));
sane_params->lvec->iov_base = sane_params->ldummy;
sane_params->lvec->iov_len = len;
sane_params->liovcnt = 1;
- sane_params->rvec = SAFE_MALLOC(NULL, sizeof(struct iovec));
+ sane_params->rvec = SAFE_MALLOC(sizeof(struct process_vm_params));
sane_params->rvec->iov_base = sane_params->rdummy;
sane_params->rvec->iov_len = len;
sane_params->riovcnt = 1;
@@ -197,7 +58,7 @@ static struct process_vm_params *cma_alloc_sane_params(void)
return sane_params;
}
-static void cma_free_params(struct process_vm_params *params)
+static void free_params(struct process_vm_params *params)
{
if (params) {
free(params->ldummy);
@@ -208,195 +69,244 @@ static void cma_free_params(struct process_vm_params *params)
}
}
-static void cma_test_sane_params(void)
+static void test_readv(struct process_vm_params *params)
+{
+ TEST(tst_syscall(__NR_process_vm_readv,
+ params->pid,
+ params->lvec, params->liovcnt,
+ params->rvec, params->riovcnt,
+ params->flags));
+}
+
+static void test_writev(struct process_vm_params *params)
+{
+ TEST(tst_syscall(__NR_process_vm_writev,
+ params->pid,
+ params->lvec, params->liovcnt,
+ params->rvec, params->riovcnt,
+ params->flags));
+}
+
+static void check_errno(long expected_errno)
+{
+ if (TST_ERR == expected_errno)
+ tst_res(TPASS | TTERRNO, "expected failure");
+ else if (TST_ERR == 0)
+ tst_res(TFAIL, "call succeeded unexpectedly");
+ else
+ tst_res(TFAIL | TTERRNO, "unexpected failure - "
+ "expected = %ld : %s, actual",
+ expected_errno, strerror(expected_errno));
+}
+
+static void test_sane_params(void)
{
struct process_vm_params *sane_params;
- sane_params = cma_alloc_sane_params();
- tst_resm(TINFO, "test_sane_params");
- cma_test_params(sane_params);
- cma_check_ret(sane_params->len, TEST_RETURN);
- cma_free_params(sane_params);
+ tst_res(TINFO, "Testing sane parameters");
+
+ sane_params = alloc_params();
+ test_params(sane_params);
+ TST_EXP_EQ_LI(TST_RET, sane_params->len);
+ free_params(sane_params);
}
-static void cma_test_flags(void)
+static void test_flags(void)
{
struct process_vm_params *params;
long flags[] = { -INT_MAX, -1, 1, INT_MAX, 0 };
- int flags_size = sizeof(flags) / sizeof(flags[0]);
+ int flags_size = ARRAY_SIZE(flags) / sizeof(flags[0]);
int i;
- params = cma_alloc_sane_params();
+ params = alloc_params();
+
for (i = 0; i < flags_size; i++) {
params->flags = flags[i];
- tst_resm(TINFO, "test_flags, flags=%ld", flags[i]);
- cma_test_params(params);
+
+ tst_res(TINFO, "Testing flags=%ld", flags[i]);
+ test_params(params);
+
/* atm. only flags == 0 is allowed, everything else
- * should fail with EINVAL */
+ * should fail with EINVAL
+ */
if (flags[i] != 0) {
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(EINVAL);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EINVAL);
} else {
- cma_check_ret(params->len, TEST_RETURN);
+ TST_EXP_EQ_LI(TST_RET, params->len);
}
}
- cma_free_params(params);
+
+ free_params(params);
}
-static void cma_test_iov_len_overflow(void)
+static void test_iov_len_overflow(void)
{
struct process_vm_params *params;
- ssize_t maxlen = -1;
- params = cma_alloc_sane_params();
-
- params->lvec->iov_len = maxlen;
- params->rvec->iov_len = maxlen;
- tst_resm(TINFO, "test_iov_len_overflow");
- cma_test_params(params);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(EINVAL);
- cma_free_params(params);
+
+ tst_res(TINFO, "Testing iov_len = -1");
+
+ params = alloc_params();
+ params->lvec->iov_len = -1;
+ params->rvec->iov_len = -1;
+ test_params(params);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EINVAL);
+ free_params(params);
}
-static void cma_test_iov_invalid(void)
+static void test_iov_invalid(void)
{
struct process_vm_params *sane_params;
struct process_vm_params params_copy;
- sane_params = cma_alloc_sane_params();
- /* make a shallow copy we can 'damage' */
+ sane_params = alloc_params();
+ tst_res(TINFO, "Testing lvec->iov_base = -1");
params_copy = *sane_params;
- tst_resm(TINFO, "test_iov_invalid - lvec->iov_base");
params_copy.lvec->iov_base = (void *)-1;
- cma_test_params(¶ms_copy);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(EFAULT);
+ test_params(¶ms_copy);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EFAULT);
+ tst_res(TINFO, "Testing rvec->iov_base = -1");
params_copy = *sane_params;
- tst_resm(TINFO, "test_iov_invalid - rvec->iov_base");
params_copy.rvec->iov_base = (void *)-1;
- cma_test_params(¶ms_copy);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(EFAULT);
+ test_params(¶ms_copy);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EFAULT);
+ tst_res(TINFO, "Testing lvec = -1");
params_copy = *sane_params;
- tst_resm(TINFO, "test_iov_invalid - lvec");
params_copy.lvec = (void *)-1;
- cma_test_params(¶ms_copy);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(EFAULT);
+ test_params(¶ms_copy);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EFAULT);
+ tst_res(TINFO, "Testing rvec = -1");
params_copy = *sane_params;
- tst_resm(TINFO, "test_iov_invalid - rvec");
params_copy.rvec = (void *)-1;
- cma_test_params(¶ms_copy);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(EFAULT);
+ test_params(¶ms_copy);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EFAULT);
- cma_free_params(sane_params);
+ free_params(sane_params);
}
-static void cma_test_invalid_pid(void)
+static void test_invalid_pid(void)
{
pid_t invalid_pid = -1;
struct process_vm_params *params;
+ struct process_vm_params params_copy;
+
+ params = alloc_params();
+
+ tst_res(TINFO, "Testing invalid PID");
+ params_copy = *params;
+ params_copy.pid = invalid_pid;
+ test_params(¶ms_copy);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(ESRCH);
- params = cma_alloc_sane_params();
- tst_resm(TINFO, "test_invalid_pid");
- params->pid = invalid_pid;
- cma_test_params(params);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(ESRCH);
- cma_free_params(params);
-
- invalid_pid = tst_get_unused_pid(cleanup);
-
- params = cma_alloc_sane_params();
- params->pid = invalid_pid;
- cma_test_params(params);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(ESRCH);
- cma_free_params(params);
+ tst_res(TINFO, "Testing unused PID");
+ params_copy = *params;
+ invalid_pid = tst_get_unused_pid();
+ params_copy.pid = invalid_pid;
+ test_params(¶ms_copy);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(ESRCH);
+
+ free_params(params);
}
-static void cma_test_invalid_perm(void)
+static void test_invalid_perm(void)
{
char nobody_uid[] = "nobody";
struct passwd *ltpuser;
- int status;
struct process_vm_params *params;
pid_t child_pid;
pid_t parent_pid;
- int ret = 0;
+ int status;
+
+ tst_res(TINFO, "Testing invalid permissions on given PID");
- tst_resm(TINFO, "test_invalid_perm");
parent_pid = getpid();
- child_pid = fork();
- switch (child_pid) {
- case -1:
- tst_brkm(TBROK | TERRNO, cleanup, "fork");
- break;
- case 0:
- ltpuser = getpwnam(nobody_uid);
- if (ltpuser == NULL)
- tst_brkm(TBROK | TERRNO, NULL, "getpwnam failed");
- SAFE_SETUID(NULL, ltpuser->pw_uid);
-
- params = cma_alloc_sane_params();
+ child_pid = SAFE_FORK();
+ if (!child_pid) {
+ ltpuser = SAFE_GETPWNAM(nobody_uid);
+ SAFE_SETUID(ltpuser->pw_uid);
+
+ params = alloc_params();
params->pid = parent_pid;
- cma_test_params(params);
- ret |= cma_check_ret(-1, TEST_RETURN);
- ret |= cma_check_errno(EPERM);
- cma_free_params(params);
- exit(ret);
- default:
- SAFE_WAITPID(cleanup, child_pid, &status, 0);
- if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
- tst_resm(TFAIL, "child returns %d", status);
+ test_params(params);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EPERM);
+ free_params(params);
+ return;
}
+
+ SAFE_WAITPID(child_pid, &status, 0);
}
-static void cma_test_invalid_protection(void)
+static void test_invalid_protection(void)
{
struct process_vm_params *sane_params;
struct process_vm_params params_copy;
- void *p;
-
- sane_params = cma_alloc_sane_params();
- /* make a shallow copy we can 'damage' */
+ void *data;
+ int len;
- p = mmap(NULL, getpagesize(), PROT_NONE,
- MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
- if (p == MAP_FAILED)
- tst_brkm(TBROK | TERRNO, cleanup, "mmap");
+ len = getpagesize();
+ sane_params = alloc_params();
+ data = SAFE_MMAP(NULL, len, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+ tst_res(TINFO, "Testing data with invalid protection (lvec)");
params_copy = *sane_params;
- params_copy.lvec->iov_base = p;
- tst_resm(TINFO, "test_invalid_protection lvec");
- cma_test_params(¶ms_copy);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(EFAULT);
+ params_copy.lvec->iov_base = data;
+ test_params(¶ms_copy);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EFAULT);
+ tst_res(TINFO, "Testing data with invalid protection (rvec)");
params_copy = *sane_params;
- params_copy.rvec->iov_base = p;
- tst_resm(TINFO, "test_invalid_protection rvec");
- cma_test_params(¶ms_copy);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(EFAULT);
+ params_copy.rvec->iov_base = data;
+ test_params(¶ms_copy);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EFAULT);
- SAFE_MUNMAP(cleanup, p, getpagesize());
+ SAFE_MUNMAP(data, len);
+ free_params(sane_params);
+}
- cma_free_params(sane_params);
+static void run(void)
+{
+ test_sane_params();
+ test_flags();
+ test_iov_len_overflow();
+ test_iov_invalid();
+ test_invalid_pid();
+ test_invalid_perm();
+ test_invalid_protection();
}
-static void cma_test_errnos(void)
+static void setup(void)
{
- cma_test_sane_params();
- cma_test_flags();
- cma_test_iov_len_overflow();
- cma_test_iov_invalid();
- cma_test_invalid_pid();
- cma_test_invalid_perm();
- cma_test_invalid_protection();
+ if (str_read) {
+ tst_res(TINFO, "Selected process_vm_readv");
+ test_params = test_readv;
+ } else {
+ tst_res(TINFO, "Selected process_vm_writev");
+ test_params = test_writev;
+ }
}
+
+static struct tst_test test = {
+ .test_all = run,
+ .setup = setup,
+ .forks_child = 1,
+ .needs_checkpoints = 1,
+ .needs_root = 1,
+ .options = (struct tst_option[]) {
+ {"r", &str_read, "Use process_vm_read instead of process_vm_write"},
+ {},
+ },
+};
--
2.35.3
--
Mailing list info: https://lists.linux.it/listinfo/ltp
^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [LTP] [PATCH v1] Rewrite process_vm01 test using new LTP API
2022-08-24 12:40 [LTP] [PATCH v1] Rewrite process_vm01 test using new LTP API Andrea Cervesato via ltp
@ 2022-08-26 7:04 ` Richard Palethorpe
2022-08-26 8:40 ` Andrea Cervesato via ltp
0 siblings, 1 reply; 7+ messages in thread
From: Richard Palethorpe @ 2022-08-26 7:04 UTC (permalink / raw)
To: Andrea Cervesato; +Cc: ltp
Hello,
Andrea Cervesato via ltp <ltp@lists.linux.it> writes:
> -static void cma_test_invalid_perm(void)
> +static void test_invalid_perm(void)
> {
> char nobody_uid[] = "nobody";
> struct passwd *ltpuser;
> - int status;
> struct process_vm_params *params;
> pid_t child_pid;
> pid_t parent_pid;
> - int ret = 0;
> + int status;
> +
> + tst_res(TINFO, "Testing invalid permissions on given PID");
>
> - tst_resm(TINFO, "test_invalid_perm");
> parent_pid = getpid();
> - child_pid = fork();
> - switch (child_pid) {
> - case -1:
> - tst_brkm(TBROK | TERRNO, cleanup, "fork");
> - break;
> - case 0:
> - ltpuser = getpwnam(nobody_uid);
> - if (ltpuser == NULL)
> - tst_brkm(TBROK | TERRNO, NULL, "getpwnam failed");
> - SAFE_SETUID(NULL, ltpuser->pw_uid);
> -
> - params = cma_alloc_sane_params();
> + child_pid = SAFE_FORK();
> + if (!child_pid) {
> + ltpuser = SAFE_GETPWNAM(nobody_uid);
> + SAFE_SETUID(ltpuser->pw_uid);
> +
> + params = alloc_params();
> params->pid = parent_pid;
> - cma_test_params(params);
> - ret |= cma_check_ret(-1, TEST_RETURN);
> - ret |= cma_check_errno(EPERM);
> - cma_free_params(params);
> - exit(ret);
> - default:
> - SAFE_WAITPID(cleanup, child_pid, &status, 0);
> - if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
> - tst_resm(TFAIL, "child returns %d", status);
> + test_params(params);
> + TST_EXP_EQ_LI(TST_RET, -1);
> + check_errno(EPERM);
> + free_params(params);
> + return;
> }
> +
> + SAFE_WAITPID(child_pid, &status, 0);
We want to use tst_reap_children() here which will check the exit
status.
In fact, if SAFE_WAITPID is removed altogether then the exit status will
be checked automatically at the end of the test when the lib calls
reap_children.
Otherwise LGTM!
--
Thank you,
Richard.
--
Mailing list info: https://lists.linux.it/listinfo/ltp
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [LTP] [PATCH v1] Rewrite process_vm01 test using new LTP API
2022-08-26 7:04 ` Richard Palethorpe
@ 2022-08-26 8:40 ` Andrea Cervesato via ltp
2022-08-26 8:46 ` Andrea Cervesato via ltp
0 siblings, 1 reply; 7+ messages in thread
From: Andrea Cervesato via ltp @ 2022-08-26 8:40 UTC (permalink / raw)
To: rpalethorpe; +Cc: ltp
Hi!
On 8/26/22 09:04, Richard Palethorpe wrote:
> Hello,
>
> Andrea Cervesato via ltp <ltp@lists.linux.it> writes:
>
>> -static void cma_test_invalid_perm(void)
>> +static void test_invalid_perm(void)
>> {
>> char nobody_uid[] = "nobody";
>> struct passwd *ltpuser;
>> - int status;
>> struct process_vm_params *params;
>> pid_t child_pid;
>> pid_t parent_pid;
>> - int ret = 0;
>> + int status;
>> +
>> + tst_res(TINFO, "Testing invalid permissions on given PID");
>>
>> - tst_resm(TINFO, "test_invalid_perm");
>> parent_pid = getpid();
>> - child_pid = fork();
>> - switch (child_pid) {
>> - case -1:
>> - tst_brkm(TBROK | TERRNO, cleanup, "fork");
>> - break;
>> - case 0:
>> - ltpuser = getpwnam(nobody_uid);
>> - if (ltpuser == NULL)
>> - tst_brkm(TBROK | TERRNO, NULL, "getpwnam failed");
>> - SAFE_SETUID(NULL, ltpuser->pw_uid);
>> -
>> - params = cma_alloc_sane_params();
>> + child_pid = SAFE_FORK();
>> + if (!child_pid) {
>> + ltpuser = SAFE_GETPWNAM(nobody_uid);
>> + SAFE_SETUID(ltpuser->pw_uid);
>> +
>> + params = alloc_params();
>> params->pid = parent_pid;
>> - cma_test_params(params);
>> - ret |= cma_check_ret(-1, TEST_RETURN);
>> - ret |= cma_check_errno(EPERM);
>> - cma_free_params(params);
>> - exit(ret);
>> - default:
>> - SAFE_WAITPID(cleanup, child_pid, &status, 0);
>> - if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
>> - tst_resm(TFAIL, "child returns %d", status);
>> + test_params(params);
>> + TST_EXP_EQ_LI(TST_RET, -1);
>> + check_errno(EPERM);
>> + free_params(params);
>> + return;
>> }
>> +
>> + SAFE_WAITPID(child_pid, &status, 0);
> We want to use tst_reap_children() here which will check the exit
> status.
>
> In fact, if SAFE_WAITPID is removed altogether then the exit status will
> be checked automatically at the end of the test when the lib calls
> reap_children.
>
> Otherwise LGTM!
>
Isn't tst_reap_childread() already called at the end of the test_all
function? (tst_test.c:1354)
Andrea
--
Mailing list info: https://lists.linux.it/listinfo/ltp
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [LTP] [PATCH v1] Rewrite process_vm01 test using new LTP API
2022-08-26 8:40 ` Andrea Cervesato via ltp
@ 2022-08-26 8:46 ` Andrea Cervesato via ltp
2022-08-26 8:50 ` Richard Palethorpe
0 siblings, 1 reply; 7+ messages in thread
From: Andrea Cervesato via ltp @ 2022-08-26 8:46 UTC (permalink / raw)
To: ltp
On 8/26/22 10:40, Andrea Cervesato via ltp wrote:
> Hi!
>
> On 8/26/22 09:04, Richard Palethorpe wrote:
>> Hello,
>>
>> Andrea Cervesato via ltp <ltp@lists.linux.it> writes:
>>
>>> -static void cma_test_invalid_perm(void)
>>> +static void test_invalid_perm(void)
>>> {
>>> char nobody_uid[] = "nobody";
>>> struct passwd *ltpuser;
>>> - int status;
>>> struct process_vm_params *params;
>>> pid_t child_pid;
>>> pid_t parent_pid;
>>> - int ret = 0;
>>> + int status;
>>> +
>>> + tst_res(TINFO, "Testing invalid permissions on given PID");
>>> - tst_resm(TINFO, "test_invalid_perm");
>>> parent_pid = getpid();
>>> - child_pid = fork();
>>> - switch (child_pid) {
>>> - case -1:
>>> - tst_brkm(TBROK | TERRNO, cleanup, "fork");
>>> - break;
>>> - case 0:
>>> - ltpuser = getpwnam(nobody_uid);
>>> - if (ltpuser == NULL)
>>> - tst_brkm(TBROK | TERRNO, NULL, "getpwnam failed");
>>> - SAFE_SETUID(NULL, ltpuser->pw_uid);
>>> -
>>> - params = cma_alloc_sane_params();
>>> + child_pid = SAFE_FORK();
>>> + if (!child_pid) {
>>> + ltpuser = SAFE_GETPWNAM(nobody_uid);
>>> + SAFE_SETUID(ltpuser->pw_uid);
>>> +
>>> + params = alloc_params();
>>> params->pid = parent_pid;
>>> - cma_test_params(params);
>>> - ret |= cma_check_ret(-1, TEST_RETURN);
>>> - ret |= cma_check_errno(EPERM);
>>> - cma_free_params(params);
>>> - exit(ret);
>>> - default:
>>> - SAFE_WAITPID(cleanup, child_pid, &status, 0);
>>> - if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
>>> - tst_resm(TFAIL, "child returns %d", status);
>>> + test_params(params);
>>> + TST_EXP_EQ_LI(TST_RET, -1);
>>> + check_errno(EPERM);
>>> + free_params(params);
>>> + return;
>>> }
>>> +
>>> + SAFE_WAITPID(child_pid, &status, 0);
>> We want to use tst_reap_children() here which will check the exit
>> status.
>>
>> In fact, if SAFE_WAITPID is removed altogether then the exit status will
>> be checked automatically at the end of the test when the lib calls
>> reap_children.
>>
>> Otherwise LGTM!
>>
> Isn't tst_reap_childread() already called at the end of the test_all
> function? (tst_test.c:1354)
>
> Andrea
>
>
The reason why I'm using SAFE_WAITPID here is that there are many other
test functions and when test_invalid_perm is called without it, the
tst_res messages might come out asynchronously with the other tests
messages.
--
Mailing list info: https://lists.linux.it/listinfo/ltp
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [LTP] [PATCH v1] Rewrite process_vm01 test using new LTP API
2022-08-26 8:46 ` Andrea Cervesato via ltp
@ 2022-08-26 8:50 ` Richard Palethorpe
0 siblings, 0 replies; 7+ messages in thread
From: Richard Palethorpe @ 2022-08-26 8:50 UTC (permalink / raw)
To: Andrea Cervesato; +Cc: ltp
Hello,
Andrea Cervesato via ltp <ltp@lists.linux.it> writes:
> On 8/26/22 10:40, Andrea Cervesato via ltp wrote:
>> Hi!
>>
>> On 8/26/22 09:04, Richard Palethorpe wrote:
>>> Hello,
>>>
>>> Andrea Cervesato via ltp <ltp@lists.linux.it> writes:
>>>
>>>> -static void cma_test_invalid_perm(void)
>>>> +static void test_invalid_perm(void)
>>>> {
>>>> char nobody_uid[] = "nobody";
>>>> struct passwd *ltpuser;
>>>> - int status;
>>>> struct process_vm_params *params;
>>>> pid_t child_pid;
>>>> pid_t parent_pid;
>>>> - int ret = 0;
>>>> + int status;
>>>> +
>>>> + tst_res(TINFO, "Testing invalid permissions on given PID");
>>>> - tst_resm(TINFO, "test_invalid_perm");
>>>> parent_pid = getpid();
>>>> - child_pid = fork();
>>>> - switch (child_pid) {
>>>> - case -1:
>>>> - tst_brkm(TBROK | TERRNO, cleanup, "fork");
>>>> - break;
>>>> - case 0:
>>>> - ltpuser = getpwnam(nobody_uid);
>>>> - if (ltpuser == NULL)
>>>> - tst_brkm(TBROK | TERRNO, NULL, "getpwnam failed");
>>>> - SAFE_SETUID(NULL, ltpuser->pw_uid);
>>>> -
>>>> - params = cma_alloc_sane_params();
>>>> + child_pid = SAFE_FORK();
>>>> + if (!child_pid) {
>>>> + ltpuser = SAFE_GETPWNAM(nobody_uid);
>>>> + SAFE_SETUID(ltpuser->pw_uid);
>>>> +
>>>> + params = alloc_params();
>>>> params->pid = parent_pid;
>>>> - cma_test_params(params);
>>>> - ret |= cma_check_ret(-1, TEST_RETURN);
>>>> - ret |= cma_check_errno(EPERM);
>>>> - cma_free_params(params);
>>>> - exit(ret);
>>>> - default:
>>>> - SAFE_WAITPID(cleanup, child_pid, &status, 0);
>>>> - if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
>>>> - tst_resm(TFAIL, "child returns %d", status);
>>>> + test_params(params);
>>>> + TST_EXP_EQ_LI(TST_RET, -1);
>>>> + check_errno(EPERM);
>>>> + free_params(params);
>>>> + return;
>>>> }
>>>> +
>>>> + SAFE_WAITPID(child_pid, &status, 0);
>>> We want to use tst_reap_children() here which will check the exit
>>> status.
>>>
>>> In fact, if SAFE_WAITPID is removed altogether then the exit status will
>>> be checked automatically at the end of the test when the lib calls
>>> reap_children.
>>>
>>> Otherwise LGTM!
>>>
>> Isn't tst_reap_childread() already called at the end of the test_all
>> function? (tst_test.c:1354)
>>
>> Andrea
>>
>>
> The reason why I'm using SAFE_WAITPID here is that there are many
> other test functions and when test_invalid_perm is called without it,
> the tst_res messages might come out asynchronously with the other
> tests messages.
If asynchronous messages are a problem then you can explicitly call
tst_reap_children() after fork. If you use SAFE_WAITPID then you need to
check the exit status manually, it won't get checked later by the call
to tst_reap_children in tst_test.c. Because the child process has
already been reaped by waitpid.
I don't have a strong opinion on whether asynchronous messages are a
problem.
--
Thank you,
Richard.
--
Mailing list info: https://lists.linux.it/listinfo/ltp
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [LTP] [PATCH v1] Rewrite process_vm01 test using new LTP API
2022-10-06 11:06 ` [LTP] [PATCH v1] Rewrite process_vm01 test using new LTP API Andrea Cervesato via ltp
@ 2022-10-06 11:10 ` Andrea Cervesato via ltp
0 siblings, 0 replies; 7+ messages in thread
From: Andrea Cervesato via ltp @ 2022-10-06 11:10 UTC (permalink / raw)
To: ltp
Hi,
this patch has been sent already. An accident using "git send-email"
command.
Andrea
On 10/6/22 13:06, Andrea Cervesato wrote:
> Now test is run on process_vm_writev by default and process_vm_readv can
> be selected by passing -r command line option.
>
> Signed-off-by: Andrea Cervesato <andrea.cervesato@suse.com>
> ---
> runtest/syscalls | 2 +-
> testcases/kernel/syscalls/cma/process_vm01.c | 464 ++++++++-----------
> 2 files changed, 188 insertions(+), 278 deletions(-)
>
> diff --git a/runtest/syscalls b/runtest/syscalls
> index 3847e8af2..70f22fbd5 100644
> --- a/runtest/syscalls
> +++ b/runtest/syscalls
> @@ -1031,7 +1031,7 @@ profil01 profil01
> process_vm_readv01 process_vm01 -r
> process_vm_readv02 process_vm_readv02
> process_vm_readv03 process_vm_readv03
> -process_vm_writev01 process_vm01 -w
> +process_vm_writev01 process_vm01
> process_vm_writev02 process_vm_writev02
>
> prot_hsymlinks prot_hsymlinks
> diff --git a/testcases/kernel/syscalls/cma/process_vm01.c b/testcases/kernel/syscalls/cma/process_vm01.c
> index 16f14d66b..bfd5c5acb 100644
> --- a/testcases/kernel/syscalls/cma/process_vm01.c
> +++ b/testcases/kernel/syscalls/cma/process_vm01.c
> @@ -1,47 +1,18 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
> /*
> - * Copyright (C) 2012 Linux Test Project, Inc.
> - *
> - * This program is free software; you can redistribute it and/or
> - * modify it under the terms of version 2 of the GNU General Public
> - * License as published by the Free Software Foundation.
> - *
> - * This program is distributed in the hope that it would be useful,
> - * but WITHOUT ANY WARRANTY; without even the implied warranty of
> - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
> - *
> - * Further, this software is distributed without any warranty that it
> - * is free of the rightful claim of any third person regarding
> - * infringement or the like. Any license provided herein, whether
> - * implied or otherwise, applies only to this software file. Patent
> - * licenses, if any, provided herein do not apply to combinations of
> - * this program with other software, or any other product whatsoever.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program; if not, write the Free Software
> - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
> - * 02110-1301, USA.
> + * Copyright (c) Linux Test Project, 2012
> + * Copyright (C) 2021 SUSE LLC Andrea Cervesato <andrea.cervesato@suse.com>
> */
>
> -/*
> - * errno tests shared by process_vm_readv, process_vm_writev tests.
> +/*\
> + * [Description]
> + *
> + * Test errno codes in process_vm_readv and process_vm_writev syscalls.
> */
> -#include <sys/types.h>
> -#include <sys/stat.h>
> -#include <sys/syscall.h>
> -#include <sys/uio.h>
> -#include <sys/wait.h>
> -#include <sys/mman.h>
> -#include <errno.h>
> -#include <signal.h>
> -#include <stdio.h>
> -#include <stdlib.h>
> -#include <string.h>
> -#include <unistd.h>
> -#include <limits.h>
> +
> #include <pwd.h>
> -#include "config.h"
> -#include "test.h"
> -#include "safe_macros.h"
> +#include <stdlib.h>
> +#include "tst_test.h"
> #include "lapi/syscalls.h"
>
> struct process_vm_params {
> @@ -56,137 +27,27 @@ struct process_vm_params {
> unsigned long flags;
> };
>
> -static int rflag;
> -static int wflag;
> -
> -static option_t options[] = {
> - {"r", &rflag, NULL},
> - {"w", &wflag, NULL},
> - {NULL, NULL, NULL}
> -};
> -
> -static char TCID_readv[] = "process_vm_readv";
> -static char TCID_writev[] = "process_vm_writev";
> -char *TCID = "cma01";
> -int TST_TOTAL = 1;
> -static void (*cma_test_params) (struct process_vm_params * params) = NULL;
> -
> -static void setup(char *argv[]);
> -static void cleanup(void);
> -static void help(void);
> -
> -static void cma_test_params_read(struct process_vm_params *params);
> -static void cma_test_params_write(struct process_vm_params *params);
> -static void cma_test_errnos(void);
> -
> -int main(int argc, char *argv[])
> -{
> - int lc;
> -
> - tst_parse_opts(argc, argv, options, &help);
> -
> - setup(argv);
> - for (lc = 0; TEST_LOOPING(lc); lc++) {
> - tst_count = 0;
> - cma_test_errnos();
> - }
> - cleanup();
> - tst_exit();
> -}
> -
> -static void setup(char *argv[])
> -{
> - tst_require_root();
> -
> - if (rflag && wflag)
> - tst_brkm(TBROK, NULL, "Parameters -r -w can not be used"
> - " at the same time.");
> - else if (rflag) {
> - TCID = TCID_readv;
> - cma_test_params = cma_test_params_read;
> - } else if (wflag) {
> - TCID = TCID_writev;
> - cma_test_params = cma_test_params_write;
> - } else
> - tst_brkm(TBROK, NULL, "Parameter missing, required -r or -w.");
> - TEST_PAUSE;
> -}
> -
> -static void cleanup(void)
> -{
> -}
> -
> -static void help(void)
> -{
> - printf(" -r Use process_vm_readv\n");
> - printf(" -w Use process_vm_writev\n");
> -}
> -
> -static void cma_test_params_read(struct process_vm_params *params)
> -{
> - TEST(tst_syscall(__NR_process_vm_readv,
> - params->pid,
> - params->lvec, params->liovcnt,
> - params->rvec, params->riovcnt,
> - params->flags));
> -}
> -
> -static void cma_test_params_write(struct process_vm_params *params)
> -{
> - TEST(tst_syscall(__NR_process_vm_writev,
> - params->pid,
> - params->lvec, params->liovcnt,
> - params->rvec, params->riovcnt,
> - params->flags));
> -}
> -
> -static int cma_check_ret(long expected_ret, long act_ret)
> -{
> - if (expected_ret == act_ret) {
> - tst_resm(TPASS, "expected ret success - "
> - "returned value = %ld", act_ret);
> - } else {
> - tst_resm(TFAIL, "unexpected failure - "
> - "returned value = %ld, expected: %ld",
> - act_ret, expected_ret);
> - return 1;
> - }
> - return 0;
> -}
> -
> -static int cma_check_errno(long expected_errno)
> -{
> - if (TEST_ERRNO == expected_errno)
> - tst_resm(TPASS | TTERRNO, "expected failure");
> - else if (TEST_ERRNO == 0) {
> - tst_resm(TFAIL, "call succeeded unexpectedly");
> - return 1;
> - } else {
> - tst_resm(TFAIL | TTERRNO, "unexpected failure - "
> - "expected = %ld : %s, actual",
> - expected_errno, strerror(expected_errno));
> - return 2;
> - }
> - return 0;
> -}
> +static char *str_read;
> +static void (*test_params)(struct process_vm_params *params);
>
> -static struct process_vm_params *cma_alloc_sane_params(void)
> +static struct process_vm_params *alloc_params(void)
> {
> struct process_vm_params *sane_params;
> int len;
>
> len = getpagesize();
> - sane_params = SAFE_MALLOC(NULL, sizeof(struct process_vm_params));
> +
> + sane_params = SAFE_MALLOC(sizeof(struct process_vm_params));
> sane_params->len = len;
> - sane_params->ldummy = SAFE_MALLOC(NULL, len);
> - sane_params->rdummy = SAFE_MALLOC(NULL, len);
> + sane_params->ldummy = SAFE_MALLOC(len);
> + sane_params->rdummy = SAFE_MALLOC(len);
>
> - sane_params->lvec = SAFE_MALLOC(NULL, sizeof(struct iovec));
> + sane_params->lvec = SAFE_MALLOC(sizeof(struct process_vm_params));
> sane_params->lvec->iov_base = sane_params->ldummy;
> sane_params->lvec->iov_len = len;
> sane_params->liovcnt = 1;
>
> - sane_params->rvec = SAFE_MALLOC(NULL, sizeof(struct iovec));
> + sane_params->rvec = SAFE_MALLOC(sizeof(struct process_vm_params));
> sane_params->rvec->iov_base = sane_params->rdummy;
> sane_params->rvec->iov_len = len;
> sane_params->riovcnt = 1;
> @@ -197,7 +58,7 @@ static struct process_vm_params *cma_alloc_sane_params(void)
> return sane_params;
> }
>
> -static void cma_free_params(struct process_vm_params *params)
> +static void free_params(struct process_vm_params *params)
> {
> if (params) {
> free(params->ldummy);
> @@ -208,195 +69,244 @@ static void cma_free_params(struct process_vm_params *params)
> }
> }
>
> -static void cma_test_sane_params(void)
> +static void test_readv(struct process_vm_params *params)
> +{
> + TEST(tst_syscall(__NR_process_vm_readv,
> + params->pid,
> + params->lvec, params->liovcnt,
> + params->rvec, params->riovcnt,
> + params->flags));
> +}
> +
> +static void test_writev(struct process_vm_params *params)
> +{
> + TEST(tst_syscall(__NR_process_vm_writev,
> + params->pid,
> + params->lvec, params->liovcnt,
> + params->rvec, params->riovcnt,
> + params->flags));
> +}
> +
> +static void check_errno(long expected_errno)
> +{
> + if (TST_ERR == expected_errno)
> + tst_res(TPASS | TTERRNO, "expected failure");
> + else if (TST_ERR == 0)
> + tst_res(TFAIL, "call succeeded unexpectedly");
> + else
> + tst_res(TFAIL | TTERRNO, "unexpected failure - "
> + "expected = %ld : %s, actual",
> + expected_errno, strerror(expected_errno));
> +}
> +
> +static void test_sane_params(void)
> {
> struct process_vm_params *sane_params;
>
> - sane_params = cma_alloc_sane_params();
> - tst_resm(TINFO, "test_sane_params");
> - cma_test_params(sane_params);
> - cma_check_ret(sane_params->len, TEST_RETURN);
> - cma_free_params(sane_params);
> + tst_res(TINFO, "Testing sane parameters");
> +
> + sane_params = alloc_params();
> + test_params(sane_params);
> + TST_EXP_EQ_LI(TST_RET, sane_params->len);
> + free_params(sane_params);
> }
>
> -static void cma_test_flags(void)
> +static void test_flags(void)
> {
> struct process_vm_params *params;
> long flags[] = { -INT_MAX, -1, 1, INT_MAX, 0 };
> - int flags_size = sizeof(flags) / sizeof(flags[0]);
> + int flags_size = ARRAY_SIZE(flags) / sizeof(flags[0]);
> int i;
>
> - params = cma_alloc_sane_params();
> + params = alloc_params();
> +
> for (i = 0; i < flags_size; i++) {
> params->flags = flags[i];
> - tst_resm(TINFO, "test_flags, flags=%ld", flags[i]);
> - cma_test_params(params);
> +
> + tst_res(TINFO, "Testing flags=%ld", flags[i]);
> + test_params(params);
> +
> /* atm. only flags == 0 is allowed, everything else
> - * should fail with EINVAL */
> + * should fail with EINVAL
> + */
> if (flags[i] != 0) {
> - cma_check_ret(-1, TEST_RETURN);
> - cma_check_errno(EINVAL);
> + TST_EXP_EQ_LI(TST_RET, -1);
> + check_errno(EINVAL);
> } else {
> - cma_check_ret(params->len, TEST_RETURN);
> + TST_EXP_EQ_LI(TST_RET, params->len);
> }
> }
> - cma_free_params(params);
> +
> + free_params(params);
> }
>
> -static void cma_test_iov_len_overflow(void)
> +static void test_iov_len_overflow(void)
> {
> struct process_vm_params *params;
> - ssize_t maxlen = -1;
> - params = cma_alloc_sane_params();
> -
> - params->lvec->iov_len = maxlen;
> - params->rvec->iov_len = maxlen;
> - tst_resm(TINFO, "test_iov_len_overflow");
> - cma_test_params(params);
> - cma_check_ret(-1, TEST_RETURN);
> - cma_check_errno(EINVAL);
> - cma_free_params(params);
> +
> + tst_res(TINFO, "Testing iov_len = -1");
> +
> + params = alloc_params();
> + params->lvec->iov_len = -1;
> + params->rvec->iov_len = -1;
> + test_params(params);
> + TST_EXP_EQ_LI(TST_RET, -1);
> + check_errno(EINVAL);
> + free_params(params);
> }
>
> -static void cma_test_iov_invalid(void)
> +static void test_iov_invalid(void)
> {
> struct process_vm_params *sane_params;
> struct process_vm_params params_copy;
>
> - sane_params = cma_alloc_sane_params();
> - /* make a shallow copy we can 'damage' */
> + sane_params = alloc_params();
>
> + tst_res(TINFO, "Testing lvec->iov_base = -1");
> params_copy = *sane_params;
> - tst_resm(TINFO, "test_iov_invalid - lvec->iov_base");
> params_copy.lvec->iov_base = (void *)-1;
> - cma_test_params(¶ms_copy);
> - cma_check_ret(-1, TEST_RETURN);
> - cma_check_errno(EFAULT);
> + test_params(¶ms_copy);
> + TST_EXP_EQ_LI(TST_RET, -1);
> + check_errno(EFAULT);
>
> + tst_res(TINFO, "Testing rvec->iov_base = -1");
> params_copy = *sane_params;
> - tst_resm(TINFO, "test_iov_invalid - rvec->iov_base");
> params_copy.rvec->iov_base = (void *)-1;
> - cma_test_params(¶ms_copy);
> - cma_check_ret(-1, TEST_RETURN);
> - cma_check_errno(EFAULT);
> + test_params(¶ms_copy);
> + TST_EXP_EQ_LI(TST_RET, -1);
> + check_errno(EFAULT);
>
> + tst_res(TINFO, "Testing lvec = -1");
> params_copy = *sane_params;
> - tst_resm(TINFO, "test_iov_invalid - lvec");
> params_copy.lvec = (void *)-1;
> - cma_test_params(¶ms_copy);
> - cma_check_ret(-1, TEST_RETURN);
> - cma_check_errno(EFAULT);
> + test_params(¶ms_copy);
> + TST_EXP_EQ_LI(TST_RET, -1);
> + check_errno(EFAULT);
>
> + tst_res(TINFO, "Testing rvec = -1");
> params_copy = *sane_params;
> - tst_resm(TINFO, "test_iov_invalid - rvec");
> params_copy.rvec = (void *)-1;
> - cma_test_params(¶ms_copy);
> - cma_check_ret(-1, TEST_RETURN);
> - cma_check_errno(EFAULT);
> + test_params(¶ms_copy);
> + TST_EXP_EQ_LI(TST_RET, -1);
> + check_errno(EFAULT);
>
> - cma_free_params(sane_params);
> + free_params(sane_params);
> }
>
> -static void cma_test_invalid_pid(void)
> +static void test_invalid_pid(void)
> {
> pid_t invalid_pid = -1;
> struct process_vm_params *params;
> + struct process_vm_params params_copy;
> +
> + params = alloc_params();
> +
> + tst_res(TINFO, "Testing invalid PID");
> + params_copy = *params;
> + params_copy.pid = invalid_pid;
> + test_params(¶ms_copy);
> + TST_EXP_EQ_LI(TST_RET, -1);
> + check_errno(ESRCH);
>
> - params = cma_alloc_sane_params();
> - tst_resm(TINFO, "test_invalid_pid");
> - params->pid = invalid_pid;
> - cma_test_params(params);
> - cma_check_ret(-1, TEST_RETURN);
> - cma_check_errno(ESRCH);
> - cma_free_params(params);
> -
> - invalid_pid = tst_get_unused_pid(cleanup);
> -
> - params = cma_alloc_sane_params();
> - params->pid = invalid_pid;
> - cma_test_params(params);
> - cma_check_ret(-1, TEST_RETURN);
> - cma_check_errno(ESRCH);
> - cma_free_params(params);
> + tst_res(TINFO, "Testing unused PID");
> + params_copy = *params;
> + invalid_pid = tst_get_unused_pid();
> + params_copy.pid = invalid_pid;
> + test_params(¶ms_copy);
> + TST_EXP_EQ_LI(TST_RET, -1);
> + check_errno(ESRCH);
> +
> + free_params(params);
> }
>
> -static void cma_test_invalid_perm(void)
> +static void test_invalid_perm(void)
> {
> char nobody_uid[] = "nobody";
> struct passwd *ltpuser;
> - int status;
> struct process_vm_params *params;
> pid_t child_pid;
> pid_t parent_pid;
> - int ret = 0;
> + int status;
> +
> + tst_res(TINFO, "Testing invalid permissions on given PID");
>
> - tst_resm(TINFO, "test_invalid_perm");
> parent_pid = getpid();
> - child_pid = fork();
> - switch (child_pid) {
> - case -1:
> - tst_brkm(TBROK | TERRNO, cleanup, "fork");
> - break;
> - case 0:
> - ltpuser = getpwnam(nobody_uid);
> - if (ltpuser == NULL)
> - tst_brkm(TBROK | TERRNO, NULL, "getpwnam failed");
> - SAFE_SETUID(NULL, ltpuser->pw_uid);
> -
> - params = cma_alloc_sane_params();
> + child_pid = SAFE_FORK();
> + if (!child_pid) {
> + ltpuser = SAFE_GETPWNAM(nobody_uid);
> + SAFE_SETUID(ltpuser->pw_uid);
> +
> + params = alloc_params();
> params->pid = parent_pid;
> - cma_test_params(params);
> - ret |= cma_check_ret(-1, TEST_RETURN);
> - ret |= cma_check_errno(EPERM);
> - cma_free_params(params);
> - exit(ret);
> - default:
> - SAFE_WAITPID(cleanup, child_pid, &status, 0);
> - if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
> - tst_resm(TFAIL, "child returns %d", status);
> + test_params(params);
> + TST_EXP_EQ_LI(TST_RET, -1);
> + check_errno(EPERM);
> + free_params(params);
> + return;
> }
> +
> + SAFE_WAITPID(child_pid, &status, 0);
> }
>
> -static void cma_test_invalid_protection(void)
> +static void test_invalid_protection(void)
> {
> struct process_vm_params *sane_params;
> struct process_vm_params params_copy;
> - void *p;
> -
> - sane_params = cma_alloc_sane_params();
> - /* make a shallow copy we can 'damage' */
> + void *data;
> + int len;
>
> - p = mmap(NULL, getpagesize(), PROT_NONE,
> - MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
> - if (p == MAP_FAILED)
> - tst_brkm(TBROK | TERRNO, cleanup, "mmap");
> + len = getpagesize();
> + sane_params = alloc_params();
> + data = SAFE_MMAP(NULL, len, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
>
> + tst_res(TINFO, "Testing data with invalid protection (lvec)");
> params_copy = *sane_params;
> - params_copy.lvec->iov_base = p;
> - tst_resm(TINFO, "test_invalid_protection lvec");
> - cma_test_params(¶ms_copy);
> - cma_check_ret(-1, TEST_RETURN);
> - cma_check_errno(EFAULT);
> + params_copy.lvec->iov_base = data;
> + test_params(¶ms_copy);
> + TST_EXP_EQ_LI(TST_RET, -1);
> + check_errno(EFAULT);
>
> + tst_res(TINFO, "Testing data with invalid protection (rvec)");
> params_copy = *sane_params;
> - params_copy.rvec->iov_base = p;
> - tst_resm(TINFO, "test_invalid_protection rvec");
> - cma_test_params(¶ms_copy);
> - cma_check_ret(-1, TEST_RETURN);
> - cma_check_errno(EFAULT);
> + params_copy.rvec->iov_base = data;
> + test_params(¶ms_copy);
> + TST_EXP_EQ_LI(TST_RET, -1);
> + check_errno(EFAULT);
>
> - SAFE_MUNMAP(cleanup, p, getpagesize());
> + SAFE_MUNMAP(data, len);
> + free_params(sane_params);
> +}
>
> - cma_free_params(sane_params);
> +static void run(void)
> +{
> + test_sane_params();
> + test_flags();
> + test_iov_len_overflow();
> + test_iov_invalid();
> + test_invalid_pid();
> + test_invalid_perm();
> + test_invalid_protection();
> }
>
> -static void cma_test_errnos(void)
> +static void setup(void)
> {
> - cma_test_sane_params();
> - cma_test_flags();
> - cma_test_iov_len_overflow();
> - cma_test_iov_invalid();
> - cma_test_invalid_pid();
> - cma_test_invalid_perm();
> - cma_test_invalid_protection();
> + if (str_read) {
> + tst_res(TINFO, "Selected process_vm_readv");
> + test_params = test_readv;
> + } else {
> + tst_res(TINFO, "Selected process_vm_writev");
> + test_params = test_writev;
> + }
> }
> +
> +static struct tst_test test = {
> + .test_all = run,
> + .setup = setup,
> + .forks_child = 1,
> + .needs_checkpoints = 1,
> + .needs_root = 1,
> + .options = (struct tst_option[]) {
> + {"r", &str_read, "Use process_vm_read instead of process_vm_write"},
> + {},
> + },
> +};
--
Mailing list info: https://lists.linux.it/listinfo/ltp
^ permalink raw reply [flat|nested] 7+ messages in thread
* [LTP] [PATCH v1] Rewrite process_vm01 test using new LTP API
2022-10-06 11:06 [LTP] [PATCH v1 0/3] Add process_madvise support Andrea Cervesato via ltp
@ 2022-10-06 11:06 ` Andrea Cervesato via ltp
2022-10-06 11:10 ` Andrea Cervesato via ltp
0 siblings, 1 reply; 7+ messages in thread
From: Andrea Cervesato via ltp @ 2022-10-06 11:06 UTC (permalink / raw)
To: ltp
Now test is run on process_vm_writev by default and process_vm_readv can
be selected by passing -r command line option.
Signed-off-by: Andrea Cervesato <andrea.cervesato@suse.com>
---
runtest/syscalls | 2 +-
testcases/kernel/syscalls/cma/process_vm01.c | 464 ++++++++-----------
2 files changed, 188 insertions(+), 278 deletions(-)
diff --git a/runtest/syscalls b/runtest/syscalls
index 3847e8af2..70f22fbd5 100644
--- a/runtest/syscalls
+++ b/runtest/syscalls
@@ -1031,7 +1031,7 @@ profil01 profil01
process_vm_readv01 process_vm01 -r
process_vm_readv02 process_vm_readv02
process_vm_readv03 process_vm_readv03
-process_vm_writev01 process_vm01 -w
+process_vm_writev01 process_vm01
process_vm_writev02 process_vm_writev02
prot_hsymlinks prot_hsymlinks
diff --git a/testcases/kernel/syscalls/cma/process_vm01.c b/testcases/kernel/syscalls/cma/process_vm01.c
index 16f14d66b..bfd5c5acb 100644
--- a/testcases/kernel/syscalls/cma/process_vm01.c
+++ b/testcases/kernel/syscalls/cma/process_vm01.c
@@ -1,47 +1,18 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
/*
- * Copyright (C) 2012 Linux Test Project, Inc.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU General Public
- * License as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it would be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- *
- * Further, this software is distributed without any warranty that it
- * is free of the rightful claim of any third person regarding
- * infringement or the like. Any license provided herein, whether
- * implied or otherwise, applies only to this software file. Patent
- * licenses, if any, provided herein do not apply to combinations of
- * this program with other software, or any other product whatsoever.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
+ * Copyright (c) Linux Test Project, 2012
+ * Copyright (C) 2021 SUSE LLC Andrea Cervesato <andrea.cervesato@suse.com>
*/
-/*
- * errno tests shared by process_vm_readv, process_vm_writev tests.
+/*\
+ * [Description]
+ *
+ * Test errno codes in process_vm_readv and process_vm_writev syscalls.
*/
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/syscall.h>
-#include <sys/uio.h>
-#include <sys/wait.h>
-#include <sys/mman.h>
-#include <errno.h>
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <limits.h>
+
#include <pwd.h>
-#include "config.h"
-#include "test.h"
-#include "safe_macros.h"
+#include <stdlib.h>
+#include "tst_test.h"
#include "lapi/syscalls.h"
struct process_vm_params {
@@ -56,137 +27,27 @@ struct process_vm_params {
unsigned long flags;
};
-static int rflag;
-static int wflag;
-
-static option_t options[] = {
- {"r", &rflag, NULL},
- {"w", &wflag, NULL},
- {NULL, NULL, NULL}
-};
-
-static char TCID_readv[] = "process_vm_readv";
-static char TCID_writev[] = "process_vm_writev";
-char *TCID = "cma01";
-int TST_TOTAL = 1;
-static void (*cma_test_params) (struct process_vm_params * params) = NULL;
-
-static void setup(char *argv[]);
-static void cleanup(void);
-static void help(void);
-
-static void cma_test_params_read(struct process_vm_params *params);
-static void cma_test_params_write(struct process_vm_params *params);
-static void cma_test_errnos(void);
-
-int main(int argc, char *argv[])
-{
- int lc;
-
- tst_parse_opts(argc, argv, options, &help);
-
- setup(argv);
- for (lc = 0; TEST_LOOPING(lc); lc++) {
- tst_count = 0;
- cma_test_errnos();
- }
- cleanup();
- tst_exit();
-}
-
-static void setup(char *argv[])
-{
- tst_require_root();
-
- if (rflag && wflag)
- tst_brkm(TBROK, NULL, "Parameters -r -w can not be used"
- " at the same time.");
- else if (rflag) {
- TCID = TCID_readv;
- cma_test_params = cma_test_params_read;
- } else if (wflag) {
- TCID = TCID_writev;
- cma_test_params = cma_test_params_write;
- } else
- tst_brkm(TBROK, NULL, "Parameter missing, required -r or -w.");
- TEST_PAUSE;
-}
-
-static void cleanup(void)
-{
-}
-
-static void help(void)
-{
- printf(" -r Use process_vm_readv\n");
- printf(" -w Use process_vm_writev\n");
-}
-
-static void cma_test_params_read(struct process_vm_params *params)
-{
- TEST(tst_syscall(__NR_process_vm_readv,
- params->pid,
- params->lvec, params->liovcnt,
- params->rvec, params->riovcnt,
- params->flags));
-}
-
-static void cma_test_params_write(struct process_vm_params *params)
-{
- TEST(tst_syscall(__NR_process_vm_writev,
- params->pid,
- params->lvec, params->liovcnt,
- params->rvec, params->riovcnt,
- params->flags));
-}
-
-static int cma_check_ret(long expected_ret, long act_ret)
-{
- if (expected_ret == act_ret) {
- tst_resm(TPASS, "expected ret success - "
- "returned value = %ld", act_ret);
- } else {
- tst_resm(TFAIL, "unexpected failure - "
- "returned value = %ld, expected: %ld",
- act_ret, expected_ret);
- return 1;
- }
- return 0;
-}
-
-static int cma_check_errno(long expected_errno)
-{
- if (TEST_ERRNO == expected_errno)
- tst_resm(TPASS | TTERRNO, "expected failure");
- else if (TEST_ERRNO == 0) {
- tst_resm(TFAIL, "call succeeded unexpectedly");
- return 1;
- } else {
- tst_resm(TFAIL | TTERRNO, "unexpected failure - "
- "expected = %ld : %s, actual",
- expected_errno, strerror(expected_errno));
- return 2;
- }
- return 0;
-}
+static char *str_read;
+static void (*test_params)(struct process_vm_params *params);
-static struct process_vm_params *cma_alloc_sane_params(void)
+static struct process_vm_params *alloc_params(void)
{
struct process_vm_params *sane_params;
int len;
len = getpagesize();
- sane_params = SAFE_MALLOC(NULL, sizeof(struct process_vm_params));
+
+ sane_params = SAFE_MALLOC(sizeof(struct process_vm_params));
sane_params->len = len;
- sane_params->ldummy = SAFE_MALLOC(NULL, len);
- sane_params->rdummy = SAFE_MALLOC(NULL, len);
+ sane_params->ldummy = SAFE_MALLOC(len);
+ sane_params->rdummy = SAFE_MALLOC(len);
- sane_params->lvec = SAFE_MALLOC(NULL, sizeof(struct iovec));
+ sane_params->lvec = SAFE_MALLOC(sizeof(struct process_vm_params));
sane_params->lvec->iov_base = sane_params->ldummy;
sane_params->lvec->iov_len = len;
sane_params->liovcnt = 1;
- sane_params->rvec = SAFE_MALLOC(NULL, sizeof(struct iovec));
+ sane_params->rvec = SAFE_MALLOC(sizeof(struct process_vm_params));
sane_params->rvec->iov_base = sane_params->rdummy;
sane_params->rvec->iov_len = len;
sane_params->riovcnt = 1;
@@ -197,7 +58,7 @@ static struct process_vm_params *cma_alloc_sane_params(void)
return sane_params;
}
-static void cma_free_params(struct process_vm_params *params)
+static void free_params(struct process_vm_params *params)
{
if (params) {
free(params->ldummy);
@@ -208,195 +69,244 @@ static void cma_free_params(struct process_vm_params *params)
}
}
-static void cma_test_sane_params(void)
+static void test_readv(struct process_vm_params *params)
+{
+ TEST(tst_syscall(__NR_process_vm_readv,
+ params->pid,
+ params->lvec, params->liovcnt,
+ params->rvec, params->riovcnt,
+ params->flags));
+}
+
+static void test_writev(struct process_vm_params *params)
+{
+ TEST(tst_syscall(__NR_process_vm_writev,
+ params->pid,
+ params->lvec, params->liovcnt,
+ params->rvec, params->riovcnt,
+ params->flags));
+}
+
+static void check_errno(long expected_errno)
+{
+ if (TST_ERR == expected_errno)
+ tst_res(TPASS | TTERRNO, "expected failure");
+ else if (TST_ERR == 0)
+ tst_res(TFAIL, "call succeeded unexpectedly");
+ else
+ tst_res(TFAIL | TTERRNO, "unexpected failure - "
+ "expected = %ld : %s, actual",
+ expected_errno, strerror(expected_errno));
+}
+
+static void test_sane_params(void)
{
struct process_vm_params *sane_params;
- sane_params = cma_alloc_sane_params();
- tst_resm(TINFO, "test_sane_params");
- cma_test_params(sane_params);
- cma_check_ret(sane_params->len, TEST_RETURN);
- cma_free_params(sane_params);
+ tst_res(TINFO, "Testing sane parameters");
+
+ sane_params = alloc_params();
+ test_params(sane_params);
+ TST_EXP_EQ_LI(TST_RET, sane_params->len);
+ free_params(sane_params);
}
-static void cma_test_flags(void)
+static void test_flags(void)
{
struct process_vm_params *params;
long flags[] = { -INT_MAX, -1, 1, INT_MAX, 0 };
- int flags_size = sizeof(flags) / sizeof(flags[0]);
+ int flags_size = ARRAY_SIZE(flags) / sizeof(flags[0]);
int i;
- params = cma_alloc_sane_params();
+ params = alloc_params();
+
for (i = 0; i < flags_size; i++) {
params->flags = flags[i];
- tst_resm(TINFO, "test_flags, flags=%ld", flags[i]);
- cma_test_params(params);
+
+ tst_res(TINFO, "Testing flags=%ld", flags[i]);
+ test_params(params);
+
/* atm. only flags == 0 is allowed, everything else
- * should fail with EINVAL */
+ * should fail with EINVAL
+ */
if (flags[i] != 0) {
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(EINVAL);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EINVAL);
} else {
- cma_check_ret(params->len, TEST_RETURN);
+ TST_EXP_EQ_LI(TST_RET, params->len);
}
}
- cma_free_params(params);
+
+ free_params(params);
}
-static void cma_test_iov_len_overflow(void)
+static void test_iov_len_overflow(void)
{
struct process_vm_params *params;
- ssize_t maxlen = -1;
- params = cma_alloc_sane_params();
-
- params->lvec->iov_len = maxlen;
- params->rvec->iov_len = maxlen;
- tst_resm(TINFO, "test_iov_len_overflow");
- cma_test_params(params);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(EINVAL);
- cma_free_params(params);
+
+ tst_res(TINFO, "Testing iov_len = -1");
+
+ params = alloc_params();
+ params->lvec->iov_len = -1;
+ params->rvec->iov_len = -1;
+ test_params(params);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EINVAL);
+ free_params(params);
}
-static void cma_test_iov_invalid(void)
+static void test_iov_invalid(void)
{
struct process_vm_params *sane_params;
struct process_vm_params params_copy;
- sane_params = cma_alloc_sane_params();
- /* make a shallow copy we can 'damage' */
+ sane_params = alloc_params();
+ tst_res(TINFO, "Testing lvec->iov_base = -1");
params_copy = *sane_params;
- tst_resm(TINFO, "test_iov_invalid - lvec->iov_base");
params_copy.lvec->iov_base = (void *)-1;
- cma_test_params(¶ms_copy);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(EFAULT);
+ test_params(¶ms_copy);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EFAULT);
+ tst_res(TINFO, "Testing rvec->iov_base = -1");
params_copy = *sane_params;
- tst_resm(TINFO, "test_iov_invalid - rvec->iov_base");
params_copy.rvec->iov_base = (void *)-1;
- cma_test_params(¶ms_copy);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(EFAULT);
+ test_params(¶ms_copy);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EFAULT);
+ tst_res(TINFO, "Testing lvec = -1");
params_copy = *sane_params;
- tst_resm(TINFO, "test_iov_invalid - lvec");
params_copy.lvec = (void *)-1;
- cma_test_params(¶ms_copy);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(EFAULT);
+ test_params(¶ms_copy);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EFAULT);
+ tst_res(TINFO, "Testing rvec = -1");
params_copy = *sane_params;
- tst_resm(TINFO, "test_iov_invalid - rvec");
params_copy.rvec = (void *)-1;
- cma_test_params(¶ms_copy);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(EFAULT);
+ test_params(¶ms_copy);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EFAULT);
- cma_free_params(sane_params);
+ free_params(sane_params);
}
-static void cma_test_invalid_pid(void)
+static void test_invalid_pid(void)
{
pid_t invalid_pid = -1;
struct process_vm_params *params;
+ struct process_vm_params params_copy;
+
+ params = alloc_params();
+
+ tst_res(TINFO, "Testing invalid PID");
+ params_copy = *params;
+ params_copy.pid = invalid_pid;
+ test_params(¶ms_copy);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(ESRCH);
- params = cma_alloc_sane_params();
- tst_resm(TINFO, "test_invalid_pid");
- params->pid = invalid_pid;
- cma_test_params(params);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(ESRCH);
- cma_free_params(params);
-
- invalid_pid = tst_get_unused_pid(cleanup);
-
- params = cma_alloc_sane_params();
- params->pid = invalid_pid;
- cma_test_params(params);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(ESRCH);
- cma_free_params(params);
+ tst_res(TINFO, "Testing unused PID");
+ params_copy = *params;
+ invalid_pid = tst_get_unused_pid();
+ params_copy.pid = invalid_pid;
+ test_params(¶ms_copy);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(ESRCH);
+
+ free_params(params);
}
-static void cma_test_invalid_perm(void)
+static void test_invalid_perm(void)
{
char nobody_uid[] = "nobody";
struct passwd *ltpuser;
- int status;
struct process_vm_params *params;
pid_t child_pid;
pid_t parent_pid;
- int ret = 0;
+ int status;
+
+ tst_res(TINFO, "Testing invalid permissions on given PID");
- tst_resm(TINFO, "test_invalid_perm");
parent_pid = getpid();
- child_pid = fork();
- switch (child_pid) {
- case -1:
- tst_brkm(TBROK | TERRNO, cleanup, "fork");
- break;
- case 0:
- ltpuser = getpwnam(nobody_uid);
- if (ltpuser == NULL)
- tst_brkm(TBROK | TERRNO, NULL, "getpwnam failed");
- SAFE_SETUID(NULL, ltpuser->pw_uid);
-
- params = cma_alloc_sane_params();
+ child_pid = SAFE_FORK();
+ if (!child_pid) {
+ ltpuser = SAFE_GETPWNAM(nobody_uid);
+ SAFE_SETUID(ltpuser->pw_uid);
+
+ params = alloc_params();
params->pid = parent_pid;
- cma_test_params(params);
- ret |= cma_check_ret(-1, TEST_RETURN);
- ret |= cma_check_errno(EPERM);
- cma_free_params(params);
- exit(ret);
- default:
- SAFE_WAITPID(cleanup, child_pid, &status, 0);
- if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
- tst_resm(TFAIL, "child returns %d", status);
+ test_params(params);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EPERM);
+ free_params(params);
+ return;
}
+
+ SAFE_WAITPID(child_pid, &status, 0);
}
-static void cma_test_invalid_protection(void)
+static void test_invalid_protection(void)
{
struct process_vm_params *sane_params;
struct process_vm_params params_copy;
- void *p;
-
- sane_params = cma_alloc_sane_params();
- /* make a shallow copy we can 'damage' */
+ void *data;
+ int len;
- p = mmap(NULL, getpagesize(), PROT_NONE,
- MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
- if (p == MAP_FAILED)
- tst_brkm(TBROK | TERRNO, cleanup, "mmap");
+ len = getpagesize();
+ sane_params = alloc_params();
+ data = SAFE_MMAP(NULL, len, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+ tst_res(TINFO, "Testing data with invalid protection (lvec)");
params_copy = *sane_params;
- params_copy.lvec->iov_base = p;
- tst_resm(TINFO, "test_invalid_protection lvec");
- cma_test_params(¶ms_copy);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(EFAULT);
+ params_copy.lvec->iov_base = data;
+ test_params(¶ms_copy);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EFAULT);
+ tst_res(TINFO, "Testing data with invalid protection (rvec)");
params_copy = *sane_params;
- params_copy.rvec->iov_base = p;
- tst_resm(TINFO, "test_invalid_protection rvec");
- cma_test_params(¶ms_copy);
- cma_check_ret(-1, TEST_RETURN);
- cma_check_errno(EFAULT);
+ params_copy.rvec->iov_base = data;
+ test_params(¶ms_copy);
+ TST_EXP_EQ_LI(TST_RET, -1);
+ check_errno(EFAULT);
- SAFE_MUNMAP(cleanup, p, getpagesize());
+ SAFE_MUNMAP(data, len);
+ free_params(sane_params);
+}
- cma_free_params(sane_params);
+static void run(void)
+{
+ test_sane_params();
+ test_flags();
+ test_iov_len_overflow();
+ test_iov_invalid();
+ test_invalid_pid();
+ test_invalid_perm();
+ test_invalid_protection();
}
-static void cma_test_errnos(void)
+static void setup(void)
{
- cma_test_sane_params();
- cma_test_flags();
- cma_test_iov_len_overflow();
- cma_test_iov_invalid();
- cma_test_invalid_pid();
- cma_test_invalid_perm();
- cma_test_invalid_protection();
+ if (str_read) {
+ tst_res(TINFO, "Selected process_vm_readv");
+ test_params = test_readv;
+ } else {
+ tst_res(TINFO, "Selected process_vm_writev");
+ test_params = test_writev;
+ }
}
+
+static struct tst_test test = {
+ .test_all = run,
+ .setup = setup,
+ .forks_child = 1,
+ .needs_checkpoints = 1,
+ .needs_root = 1,
+ .options = (struct tst_option[]) {
+ {"r", &str_read, "Use process_vm_read instead of process_vm_write"},
+ {},
+ },
+};
--
2.35.3
--
Mailing list info: https://lists.linux.it/listinfo/ltp
^ permalink raw reply related [flat|nested] 7+ messages in thread
end of thread, other threads:[~2022-10-06 11:12 UTC | newest]
Thread overview: 7+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-08-24 12:40 [LTP] [PATCH v1] Rewrite process_vm01 test using new LTP API Andrea Cervesato via ltp
2022-08-26 7:04 ` Richard Palethorpe
2022-08-26 8:40 ` Andrea Cervesato via ltp
2022-08-26 8:46 ` Andrea Cervesato via ltp
2022-08-26 8:50 ` Richard Palethorpe
2022-10-06 11:06 [LTP] [PATCH v1 0/3] Add process_madvise support Andrea Cervesato via ltp
2022-10-06 11:06 ` [LTP] [PATCH v1] Rewrite process_vm01 test using new LTP API Andrea Cervesato via ltp
2022-10-06 11:10 ` Andrea Cervesato via ltp
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.