static void cma_test_invalid_pid(void)
{
const char pid_max[] = "/proc/sys/kernel/pid_max";
pid_t invalid_pid = -1;
struct process_vm_params *params;
FILE *fp;
char buff[512];
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);
fp = fopen(pid_max, "r");
if (fp == NULL)
tst_brkm(TBROK, cleanup, "Could not open %s", pid_max);
if (!fgets(buff, sizeof(buff), fp))
tst_brkm(TBROK, cleanup, "Could not read %s", pid_max);
fclose(fp);
invalid_pid = atol(buff) + 1;
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);
}
static void cma_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' */
p = mmap(NULL, getpagesize(), PROT_NONE,
MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
if (p == MAP_FAILED)
tst_brkm(TBROK | TERRNO, cleanup, "mmap");
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 = *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);
if (munmap(p, getpagesize()) < 0)
tst_brkm(TBROK | TERRNO, cleanup, "munmap");
cma_free_params(sane_params);
}
static void cma_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);
}
static void cma_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' */
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);
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);
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);
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);
cma_free_params(sane_params);
}
static void cma_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);
}
static void cma_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 i;
params = cma_alloc_sane_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);
/* atm. only flags == 0 is allowed, everything else
* should fail with EINVAL */
if (flags[i] != 0) {
cma_check_ret(-1, TEST_RETURN);
cma_check_errno(EINVAL);
} else {
cma_check_ret(params->len, TEST_RETURN);
}
}
cma_free_params(params);
}
static void cma_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;
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");
if (setuid(ltpuser->pw_uid) == -1)
tst_brkm(TBROK|TERRNO, NULL,
"setuid(%u) failed", ltpuser->pw_uid);
params = cma_alloc_sane_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:
if (waitpid(child_pid, &status, 0) == -1)
tst_brkm(TBROK|TERRNO, cleanup, "waitpid");
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
tst_resm(TFAIL, "child returns %d", status);
}
}
