selftests/powerpc: Add ptrace tests for Protection Key registers
This test exercises read and write access to the AMR, IAMR and UAMOR. Signed-off-by: Thiago Jung Bauermann <bauerman@linux.ibm.com> [mpe: Simplify make rule] Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
This commit is contained in:
Thiago Jung Bauermann
Michael Ellerman
parent
8ce621e1d9
commit
1f7256e7dd
|
|
@ -54,6 +54,7 @@
|
|||
#define SPRN_DSCR_PRIV 0x11 /* Privilege State DSCR */
|
||||
#define SPRN_DSCR 0x03 /* Data Stream Control Register */
|
||||
#define SPRN_PPR 896 /* Program Priority Register */
|
||||
#define SPRN_AMR 13 /* Authority Mask Register - problem state */
|
||||
|
||||
/* TEXASR register bits */
|
||||
#define TEXASR_FC 0xFE00000000000000
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
# SPDX-License-Identifier: GPL-2.0
|
||||
TEST_PROGS := ptrace-gpr ptrace-tm-gpr ptrace-tm-spd-gpr \
|
||||
ptrace-tar ptrace-tm-tar ptrace-tm-spd-tar ptrace-vsx ptrace-tm-vsx \
|
||||
ptrace-tm-spd-vsx ptrace-tm-spr ptrace-hwbreak
|
||||
ptrace-tm-spd-vsx ptrace-tm-spr ptrace-hwbreak ptrace-pkey
|
||||
|
||||
include ../../lib.mk
|
||||
|
||||
|
|
@ -9,6 +9,9 @@ all: $(TEST_PROGS)
|
|||
|
||||
CFLAGS += -m64 -I../../../../../usr/include -I../tm -mhtm -fno-pie
|
||||
|
||||
ptrace-pkey: child.h
|
||||
ptrace-pkey: LDLIBS += -pthread
|
||||
|
||||
$(TEST_PROGS): ../harness.c ../utils.c ../lib/reg.S ptrace.h
|
||||
|
||||
clean:
|
||||
|
|
|
|||
|
|
@ -0,0 +1,139 @@
|
|||
// SPDX-License-Identifier: GPL-2.0+
|
||||
/*
|
||||
* Helper functions to sync execution between parent and child processes.
|
||||
*
|
||||
* Copyright 2018, Thiago Jung Bauermann, IBM Corporation.
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <stdbool.h>
|
||||
#include <semaphore.h>
|
||||
|
||||
/*
|
||||
* Information in a shared memory location for synchronization between child and
|
||||
* parent.
|
||||
*/
|
||||
struct child_sync {
|
||||
/* The parent waits on this semaphore. */
|
||||
sem_t sem_parent;
|
||||
|
||||
/* If true, the child should give up as well. */
|
||||
bool parent_gave_up;
|
||||
|
||||
/* The child waits on this semaphore. */
|
||||
sem_t sem_child;
|
||||
|
||||
/* If true, the parent should give up as well. */
|
||||
bool child_gave_up;
|
||||
};
|
||||
|
||||
#define CHILD_FAIL_IF(x, sync) \
|
||||
do { \
|
||||
if (x) { \
|
||||
fprintf(stderr, \
|
||||
"[FAIL] Test FAILED on line %d\n", __LINE__); \
|
||||
(sync)->child_gave_up = true; \
|
||||
prod_parent(sync); \
|
||||
return 1; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define PARENT_FAIL_IF(x, sync) \
|
||||
do { \
|
||||
if (x) { \
|
||||
fprintf(stderr, \
|
||||
"[FAIL] Test FAILED on line %d\n", __LINE__); \
|
||||
(sync)->parent_gave_up = true; \
|
||||
prod_child(sync); \
|
||||
return 1; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define PARENT_SKIP_IF_UNSUPPORTED(x, sync) \
|
||||
do { \
|
||||
if ((x) == -1 && (errno == ENODEV || errno == EINVAL)) { \
|
||||
(sync)->parent_gave_up = true; \
|
||||
prod_child(sync); \
|
||||
SKIP_IF(1); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
int init_child_sync(struct child_sync *sync)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = sem_init(&sync->sem_parent, 1, 0);
|
||||
if (ret) {
|
||||
perror("Semaphore initialization failed");
|
||||
return 1;
|
||||
}
|
||||
|
||||
ret = sem_init(&sync->sem_child, 1, 0);
|
||||
if (ret) {
|
||||
perror("Semaphore initialization failed");
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void destroy_child_sync(struct child_sync *sync)
|
||||
{
|
||||
sem_destroy(&sync->sem_parent);
|
||||
sem_destroy(&sync->sem_child);
|
||||
}
|
||||
|
||||
int wait_child(struct child_sync *sync)
|
||||
{
|
||||
int ret;
|
||||
|
||||
/* Wait until the child prods us. */
|
||||
ret = sem_wait(&sync->sem_parent);
|
||||
if (ret) {
|
||||
perror("Error waiting for child");
|
||||
return 1;
|
||||
}
|
||||
|
||||
return sync->child_gave_up;
|
||||
}
|
||||
|
||||
int prod_child(struct child_sync *sync)
|
||||
{
|
||||
int ret;
|
||||
|
||||
/* Unblock the child now. */
|
||||
ret = sem_post(&sync->sem_child);
|
||||
if (ret) {
|
||||
perror("Error prodding child");
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int wait_parent(struct child_sync *sync)
|
||||
{
|
||||
int ret;
|
||||
|
||||
/* Wait until the parent prods us. */
|
||||
ret = sem_wait(&sync->sem_child);
|
||||
if (ret) {
|
||||
perror("Error waiting for parent");
|
||||
return 1;
|
||||
}
|
||||
|
||||
return sync->parent_gave_up;
|
||||
}
|
||||
|
||||
int prod_parent(struct child_sync *sync)
|
||||
{
|
||||
int ret;
|
||||
|
||||
/* Unblock the parent now. */
|
||||
ret = sem_post(&sync->sem_parent);
|
||||
if (ret) {
|
||||
perror("Error prodding parent");
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,327 @@
|
|||
// SPDX-License-Identifier: GPL-2.0+
|
||||
/*
|
||||
* Ptrace test for Memory Protection Key registers
|
||||
*
|
||||
* Copyright (C) 2015 Anshuman Khandual, IBM Corporation.
|
||||
* Copyright (C) 2018 IBM Corporation.
|
||||
*/
|
||||
#include "ptrace.h"
|
||||
#include "child.h"
|
||||
|
||||
#ifndef __NR_pkey_alloc
|
||||
#define __NR_pkey_alloc 384
|
||||
#endif
|
||||
|
||||
#ifndef __NR_pkey_free
|
||||
#define __NR_pkey_free 385
|
||||
#endif
|
||||
|
||||
#ifndef NT_PPC_PKEY
|
||||
#define NT_PPC_PKEY 0x110
|
||||
#endif
|
||||
|
||||
#ifndef PKEY_DISABLE_EXECUTE
|
||||
#define PKEY_DISABLE_EXECUTE 0x4
|
||||
#endif
|
||||
|
||||
#define AMR_BITS_PER_PKEY 2
|
||||
#define PKEY_REG_BITS (sizeof(u64) * 8)
|
||||
#define pkeyshift(pkey) (PKEY_REG_BITS - ((pkey + 1) * AMR_BITS_PER_PKEY))
|
||||
|
||||
static const char user_read[] = "[User Read (Running)]";
|
||||
static const char user_write[] = "[User Write (Running)]";
|
||||
static const char ptrace_read_running[] = "[Ptrace Read (Running)]";
|
||||
static const char ptrace_write_running[] = "[Ptrace Write (Running)]";
|
||||
|
||||
/* Information shared between the parent and the child. */
|
||||
struct shared_info {
|
||||
struct child_sync child_sync;
|
||||
|
||||
/* AMR value the parent expects to read from the child. */
|
||||
unsigned long amr1;
|
||||
|
||||
/* AMR value the parent is expected to write to the child. */
|
||||
unsigned long amr2;
|
||||
|
||||
/* AMR value that ptrace should refuse to write to the child. */
|
||||
unsigned long amr3;
|
||||
|
||||
/* IAMR value the parent expects to read from the child. */
|
||||
unsigned long expected_iamr;
|
||||
|
||||
/* UAMOR value the parent expects to read from the child. */
|
||||
unsigned long expected_uamor;
|
||||
|
||||
/*
|
||||
* IAMR and UAMOR values that ptrace should refuse to write to the child
|
||||
* (even though they're valid ones) because userspace doesn't have
|
||||
* access to those registers.
|
||||
*/
|
||||
unsigned long new_iamr;
|
||||
unsigned long new_uamor;
|
||||
};
|
||||
|
||||
static int sys_pkey_alloc(unsigned long flags, unsigned long init_access_rights)
|
||||
{
|
||||
return syscall(__NR_pkey_alloc, flags, init_access_rights);
|
||||
}
|
||||
|
||||
static int sys_pkey_free(int pkey)
|
||||
{
|
||||
return syscall(__NR_pkey_free, pkey);
|
||||
}
|
||||
|
||||
static int child(struct shared_info *info)
|
||||
{
|
||||
unsigned long reg;
|
||||
bool disable_execute = true;
|
||||
int pkey1, pkey2, pkey3;
|
||||
int ret;
|
||||
|
||||
/* Wait until parent fills out the initial register values. */
|
||||
ret = wait_parent(&info->child_sync);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
/* Get some pkeys so that we can change their bits in the AMR. */
|
||||
pkey1 = sys_pkey_alloc(0, PKEY_DISABLE_EXECUTE);
|
||||
if (pkey1 < 0) {
|
||||
pkey1 = sys_pkey_alloc(0, 0);
|
||||
CHILD_FAIL_IF(pkey1 < 0, &info->child_sync);
|
||||
|
||||
disable_execute = false;
|
||||
}
|
||||
|
||||
pkey2 = sys_pkey_alloc(0, 0);
|
||||
CHILD_FAIL_IF(pkey2 < 0, &info->child_sync);
|
||||
|
||||
pkey3 = sys_pkey_alloc(0, 0);
|
||||
CHILD_FAIL_IF(pkey3 < 0, &info->child_sync);
|
||||
|
||||
info->amr1 |= 3ul << pkeyshift(pkey1);
|
||||
info->amr2 |= 3ul << pkeyshift(pkey2);
|
||||
info->amr3 |= info->amr2 | 3ul << pkeyshift(pkey3);
|
||||
|
||||
if (disable_execute)
|
||||
info->expected_iamr |= 1ul << pkeyshift(pkey1);
|
||||
|
||||
info->expected_uamor |= 3ul << pkeyshift(pkey1) |
|
||||
3ul << pkeyshift(pkey2);
|
||||
info->new_iamr |= 1ul << pkeyshift(pkey1) | 1ul << pkeyshift(pkey2);
|
||||
info->new_uamor |= 3ul << pkeyshift(pkey1);
|
||||
|
||||
/*
|
||||
* We won't use pkey3. We just want a plausible but invalid key to test
|
||||
* whether ptrace will let us write to AMR bits we are not supposed to.
|
||||
*
|
||||
* This also tests whether the kernel restores the UAMOR permissions
|
||||
* after a key is freed.
|
||||
*/
|
||||
sys_pkey_free(pkey3);
|
||||
|
||||
printf("%-30s AMR: %016lx pkey1: %d pkey2: %d pkey3: %d\n",
|
||||
user_write, info->amr1, pkey1, pkey2, pkey3);
|
||||
|
||||
mtspr(SPRN_AMR, info->amr1);
|
||||
|
||||
/* Wait for parent to read our AMR value and write a new one. */
|
||||
ret = prod_parent(&info->child_sync);
|
||||
CHILD_FAIL_IF(ret, &info->child_sync);
|
||||
|
||||
ret = wait_parent(&info->child_sync);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
reg = mfspr(SPRN_AMR);
|
||||
|
||||
printf("%-30s AMR: %016lx\n", user_read, reg);
|
||||
|
||||
CHILD_FAIL_IF(reg != info->amr2, &info->child_sync);
|
||||
|
||||
/*
|
||||
* Wait for parent to try to write an invalid AMR value.
|
||||
*/
|
||||
ret = prod_parent(&info->child_sync);
|
||||
CHILD_FAIL_IF(ret, &info->child_sync);
|
||||
|
||||
ret = wait_parent(&info->child_sync);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
reg = mfspr(SPRN_AMR);
|
||||
|
||||
printf("%-30s AMR: %016lx\n", user_read, reg);
|
||||
|
||||
CHILD_FAIL_IF(reg != info->amr2, &info->child_sync);
|
||||
|
||||
/*
|
||||
* Wait for parent to try to write an IAMR and a UAMOR value. We can't
|
||||
* verify them, but we can verify that the AMR didn't change.
|
||||
*/
|
||||
ret = prod_parent(&info->child_sync);
|
||||
CHILD_FAIL_IF(ret, &info->child_sync);
|
||||
|
||||
ret = wait_parent(&info->child_sync);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
reg = mfspr(SPRN_AMR);
|
||||
|
||||
printf("%-30s AMR: %016lx\n", user_read, reg);
|
||||
|
||||
CHILD_FAIL_IF(reg != info->amr2, &info->child_sync);
|
||||
|
||||
/* Now let parent now that we are finished. */
|
||||
|
||||
ret = prod_parent(&info->child_sync);
|
||||
CHILD_FAIL_IF(ret, &info->child_sync);
|
||||
|
||||
return TEST_PASS;
|
||||
}
|
||||
|
||||
static int parent(struct shared_info *info, pid_t pid)
|
||||
{
|
||||
unsigned long regs[3];
|
||||
int ret, status;
|
||||
|
||||
/*
|
||||
* Get the initial values for AMR, IAMR and UAMOR and communicate them
|
||||
* to the child.
|
||||
*/
|
||||
ret = ptrace_read_regs(pid, NT_PPC_PKEY, regs, 3);
|
||||
PARENT_SKIP_IF_UNSUPPORTED(ret, &info->child_sync);
|
||||
PARENT_FAIL_IF(ret, &info->child_sync);
|
||||
|
||||
info->amr1 = info->amr2 = info->amr3 = regs[0];
|
||||
info->expected_iamr = info->new_iamr = regs[1];
|
||||
info->expected_uamor = info->new_uamor = regs[2];
|
||||
|
||||
/* Wake up child so that it can set itself up. */
|
||||
ret = prod_child(&info->child_sync);
|
||||
PARENT_FAIL_IF(ret, &info->child_sync);
|
||||
|
||||
ret = wait_child(&info->child_sync);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
/* Verify that we can read the pkey registers from the child. */
|
||||
ret = ptrace_read_regs(pid, NT_PPC_PKEY, regs, 3);
|
||||
PARENT_FAIL_IF(ret, &info->child_sync);
|
||||
|
||||
printf("%-30s AMR: %016lx IAMR: %016lx UAMOR: %016lx\n",
|
||||
ptrace_read_running, regs[0], regs[1], regs[2]);
|
||||
|
||||
PARENT_FAIL_IF(regs[0] != info->amr1, &info->child_sync);
|
||||
PARENT_FAIL_IF(regs[1] != info->expected_iamr, &info->child_sync);
|
||||
PARENT_FAIL_IF(regs[2] != info->expected_uamor, &info->child_sync);
|
||||
|
||||
/* Write valid AMR value in child. */
|
||||
ret = ptrace_write_regs(pid, NT_PPC_PKEY, &info->amr2, 1);
|
||||
PARENT_FAIL_IF(ret, &info->child_sync);
|
||||
|
||||
printf("%-30s AMR: %016lx\n", ptrace_write_running, info->amr2);
|
||||
|
||||
/* Wake up child so that it can verify it changed. */
|
||||
ret = prod_child(&info->child_sync);
|
||||
PARENT_FAIL_IF(ret, &info->child_sync);
|
||||
|
||||
ret = wait_child(&info->child_sync);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
/* Write invalid AMR value in child. */
|
||||
ret = ptrace_write_regs(pid, NT_PPC_PKEY, &info->amr3, 1);
|
||||
PARENT_FAIL_IF(ret, &info->child_sync);
|
||||
|
||||
printf("%-30s AMR: %016lx\n", ptrace_write_running, info->amr3);
|
||||
|
||||
/* Wake up child so that it can verify it didn't change. */
|
||||
ret = prod_child(&info->child_sync);
|
||||
PARENT_FAIL_IF(ret, &info->child_sync);
|
||||
|
||||
ret = wait_child(&info->child_sync);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
/* Try to write to IAMR. */
|
||||
regs[0] = info->amr1;
|
||||
regs[1] = info->new_iamr;
|
||||
ret = ptrace_write_regs(pid, NT_PPC_PKEY, regs, 2);
|
||||
PARENT_FAIL_IF(!ret, &info->child_sync);
|
||||
|
||||
printf("%-30s AMR: %016lx IAMR: %016lx\n",
|
||||
ptrace_write_running, regs[0], regs[1]);
|
||||
|
||||
/* Try to write to IAMR and UAMOR. */
|
||||
regs[2] = info->new_uamor;
|
||||
ret = ptrace_write_regs(pid, NT_PPC_PKEY, regs, 3);
|
||||
PARENT_FAIL_IF(!ret, &info->child_sync);
|
||||
|
||||
printf("%-30s AMR: %016lx IAMR: %016lx UAMOR: %016lx\n",
|
||||
ptrace_write_running, regs[0], regs[1], regs[2]);
|
||||
|
||||
/* Verify that all registers still have their expected values. */
|
||||
ret = ptrace_read_regs(pid, NT_PPC_PKEY, regs, 3);
|
||||
PARENT_FAIL_IF(ret, &info->child_sync);
|
||||
|
||||
printf("%-30s AMR: %016lx IAMR: %016lx UAMOR: %016lx\n",
|
||||
ptrace_read_running, regs[0], regs[1], regs[2]);
|
||||
|
||||
PARENT_FAIL_IF(regs[0] != info->amr2, &info->child_sync);
|
||||
PARENT_FAIL_IF(regs[1] != info->expected_iamr, &info->child_sync);
|
||||
PARENT_FAIL_IF(regs[2] != info->expected_uamor, &info->child_sync);
|
||||
|
||||
/* Wake up child so that it can verify AMR didn't change and wrap up. */
|
||||
ret = prod_child(&info->child_sync);
|
||||
PARENT_FAIL_IF(ret, &info->child_sync);
|
||||
|
||||
ret = wait(&status);
|
||||
if (ret != pid) {
|
||||
printf("Child's exit status not captured\n");
|
||||
ret = TEST_PASS;
|
||||
} else if (!WIFEXITED(status)) {
|
||||
printf("Child exited abnormally\n");
|
||||
ret = TEST_FAIL;
|
||||
} else
|
||||
ret = WEXITSTATUS(status) ? TEST_FAIL : TEST_PASS;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int ptrace_pkey(void)
|
||||
{
|
||||
struct shared_info *info;
|
||||
int shm_id;
|
||||
int ret;
|
||||
pid_t pid;
|
||||
|
||||
shm_id = shmget(IPC_PRIVATE, sizeof(*info), 0777 | IPC_CREAT);
|
||||
info = shmat(shm_id, NULL, 0);
|
||||
|
||||
ret = init_child_sync(&info->child_sync);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
pid = fork();
|
||||
if (pid < 0) {
|
||||
perror("fork() failed");
|
||||
ret = TEST_FAIL;
|
||||
} else if (pid == 0)
|
||||
ret = child(info);
|
||||
else
|
||||
ret = parent(info, pid);
|
||||
|
||||
shmdt(info);
|
||||
|
||||
if (pid) {
|
||||
destroy_child_sync(&info->child_sync);
|
||||
shmctl(shm_id, IPC_RMID, NULL);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
return test_harness(ptrace_pkey, "ptrace_pkey");
|
||||
}
|
||||
|
|
@ -102,6 +102,44 @@ int cont_trace(pid_t child)
|
|||
return TEST_PASS;
|
||||
}
|
||||
|
||||
int ptrace_read_regs(pid_t child, unsigned long type, unsigned long regs[],
|
||||
int n)
|
||||
{
|
||||
struct iovec iov;
|
||||
long ret;
|
||||
|
||||
FAIL_IF(start_trace(child));
|
||||
|
||||
iov.iov_base = regs;
|
||||
iov.iov_len = n * sizeof(unsigned long);
|
||||
|
||||
ret = ptrace(PTRACE_GETREGSET, child, type, &iov);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
FAIL_IF(stop_trace(child));
|
||||
|
||||
return TEST_PASS;
|
||||
}
|
||||
|
||||
long ptrace_write_regs(pid_t child, unsigned long type, unsigned long regs[],
|
||||
int n)
|
||||
{
|
||||
struct iovec iov;
|
||||
long ret;
|
||||
|
||||
FAIL_IF(start_trace(child));
|
||||
|
||||
iov.iov_base = regs;
|
||||
iov.iov_len = n * sizeof(unsigned long);
|
||||
|
||||
ret = ptrace(PTRACE_SETREGSET, child, type, &iov);
|
||||
|
||||
FAIL_IF(stop_trace(child));
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* TAR, PPR, DSCR */
|
||||
int show_tar_registers(pid_t child, unsigned long *out)
|
||||
{
|
||||
|
|
|
|||
Loading…
Reference in New Issue