Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1f7256e7 authored by Thiago Jung Bauermann's avatar Thiago Jung Bauermann Committed by Michael Ellerman
Browse files

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: default avatarThiago Jung Bauermann <bauerman@linux.ibm.com>
[mpe: Simplify make rule]
Signed-off-by: default avatarMichael Ellerman <mpe@ellerman.id.au>
parent 8ce621e1

tools/testing/selftests/powerpc/include/reg.h

+1 −0
Original line number Diff line number Diff line
@@ -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

tools/testing/selftests/powerpc/ptrace/Makefile

+4 −1
Original line number Diff line number Diff line 
# 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:

tools/testing/selftests/powerpc/ptrace/child.h

0 → 100644
+139 −0
Original line number Diff line number Diff line 
// 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;

}

tools/testing/selftests/powerpc/ptrace/ptrace-pkey.c

0 → 100644
+327 −0
Original line number Diff line number Diff line 
// 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");

}

tools/testing/selftests/powerpc/ptrace/ptrace.h

+38 −0
Original line number Diff line number Diff line
@@ -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)

{