From patchwork Mon Nov 6 08:57:42 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ram Pai X-Patchwork-Id: 834629 Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@ozlabs.org Received: from lists.ozlabs.org (lists.ozlabs.org [103.22.144.68]) (using TLSv1.2 with cipher ADH-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 3yVqfQ3rBDz9s7p for ; Mon, 6 Nov 2017 22:12:46 +1100 (AEDT) Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.b="OeK+SoQS"; dkim-atps=neutral Received: from lists.ozlabs.org (lists.ozlabs.org [IPv6:2401:3900:2:1::3]) by lists.ozlabs.org (Postfix) with ESMTP id 3yVqfQ2d0zzDrJq for ; Mon, 6 Nov 2017 22:12:46 +1100 (AEDT) Authentication-Results: lists.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.b="OeK+SoQS"; dkim-atps=neutral X-Original-To: linuxppc-dev@lists.ozlabs.org Delivered-To: linuxppc-dev@lists.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=gmail.com (client-ip=2607:f8b0:400d:c0d::242; helo=mail-qt0-x242.google.com; envelope-from=ram.n.pai@gmail.com; receiver=) Authentication-Results: lists.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.b="OeK+SoQS"; dkim-atps=neutral Received: from mail-qt0-x242.google.com (mail-qt0-x242.google.com [IPv6:2607:f8b0:400d:c0d::242]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id 3yVmk45YVQzDrJm for ; Mon, 6 Nov 2017 20:00:44 +1100 (AEDT) Received: by mail-qt0-x242.google.com with SMTP id k31so10003006qta.6 for ; Mon, 06 Nov 2017 01:00:44 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references; bh=wOhlqAQbB31D1kilVHPWN9Ze4eKmuNAjpN/GD4UrLk8=; b=OeK+SoQSFqA/z3H/wkqQR1OudthXv8ScU7GsQokq+iUVgk5OX12xSolSHK0UScQN0/ 4Delms/M2Uq9xuhOqgs+svapHPkGCUinQ4DWi4AM/gr7Y459UjYJj07U0iEK5lKhTFwv 73LpaKnbUVom/4Sw6Nc3Jw3tsDa4Cfc7yinlMXdZiwCB15F5KZfeNw4iPZr6FfAyybVK ZwQa/KhmD7sGJvDHV25F4lmlypMtTAMTtmteztO54jWoaM6iRxoj16/iOOf3JagpBbyF FjM3g7CJJanmkF2wimUjYyt+8xp1ryOCa292JjVD26k6BTZCFZI/8ggqql7/j7y1LoCx FC3A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references; bh=wOhlqAQbB31D1kilVHPWN9Ze4eKmuNAjpN/GD4UrLk8=; b=sa3okkX2uUUKeiL8zXXhafBSXQzNo0iEq3sRmHLz7/Kxo8/MgTJCIloTUuz2DaEL3t Ut/JAmeKHVgapXsI3gpoLGCo9ISFrV+9ZLOFA3pemu07aFfwA/27vitaLcGc7yeiFZyX jTVUezFu9flCg/mxYTsJVddPNQY2CB1MQVRgVdwU+/PTKVU4xhEZut5u0Akvei2RWNU/ Yg/skaeOgZjkNrJeZtV9yM0Isy6xG8pqRQ/BSYxQF+OvkpKDIMpCboWdGfTt2yMAb2k0 uuhCS027Kfb90fzUqSQo9ivqNgDvgq078DQKRvRj670C5AXeBc6ne18CKWpyX8qGo38e lgvw== X-Gm-Message-State: AMCzsaWmlmg94KxOXyBkiP1qupDqaqRbgNPL4FzbUZ1q/3NPdXoCiLQV MdEBWmjr2w9M5h1N8RwTDWw= X-Google-Smtp-Source: ABhQp+S4Ab4WP9XeImw5glYITbJ22chXVxn13j++GEP4FbXgl33ciZHhdPzy4DegIQ2+F3R/cFVLOQ== X-Received: by 10.237.63.129 with SMTP id s1mr22224704qth.89.1509958842616; Mon, 06 Nov 2017 01:00:42 -0800 (PST) Received: from localhost.localdomain (50-39-103-96.bvtn.or.frontiernet.net. [50.39.103.96]) by smtp.gmail.com with ESMTPSA id r26sm8001094qki.42.2017.11.06.01.00.40 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 06 Nov 2017 01:00:42 -0800 (PST) From: Ram Pai To: mpe@ellerman.id.au, mingo@redhat.com, akpm@linux-foundation.org, corbet@lwn.net, arnd@arndb.de Subject: [PATCH v9 50/51] selftests/powerpc: Add ptrace tests for Protection Key register Date: Mon, 6 Nov 2017 00:57:42 -0800 Message-Id: <1509958663-18737-51-git-send-email-linuxram@us.ibm.com> X-Mailer: git-send-email 1.7.1 In-Reply-To: <1509958663-18737-1-git-send-email-linuxram@us.ibm.com> References: <1509958663-18737-1-git-send-email-linuxram@us.ibm.com> X-BeenThere: linuxppc-dev@lists.ozlabs.org X-Mailman-Version: 2.1.24 Precedence: list List-Id: Linux on PowerPC Developers Mail List List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-arch@vger.kernel.org, ebiederm@xmission.com, linux-doc@vger.kernel.org, x86@kernel.org, dave.hansen@intel.com, linux-kernel@vger.kernel.org, linuxram@us.ibm.com, mhocko@kernel.org, linux-mm@kvack.org, paulus@samba.org, aneesh.kumar@linux.vnet.ibm.com, linux-kselftest@vger.kernel.org, bauerman@linux.vnet.ibm.com, linuxppc-dev@lists.ozlabs.org, khandual@linux.vnet.ibm.com Errors-To: linuxppc-dev-bounces+patchwork-incoming=ozlabs.org@lists.ozlabs.org Sender: "Linuxppc-dev" From: Thiago Jung Bauermann This test exercises read and write access to the AMR. Signed-off-by: Thiago Jung Bauermann --- tools/testing/selftests/powerpc/include/reg.h | 1 + tools/testing/selftests/powerpc/ptrace/Makefile | 5 +- .../testing/selftests/powerpc/ptrace/ptrace-pkey.c | 443 ++++++++++++++++++++ 3 files changed, 448 insertions(+), 1 deletions(-) create mode 100644 tools/testing/selftests/powerpc/ptrace/ptrace-pkey.c diff --git a/tools/testing/selftests/powerpc/include/reg.h b/tools/testing/selftests/powerpc/include/reg.h index 4afdebc..7f348c0 100644 --- a/tools/testing/selftests/powerpc/include/reg.h +++ b/tools/testing/selftests/powerpc/include/reg.h @@ -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 diff --git a/tools/testing/selftests/powerpc/ptrace/Makefile b/tools/testing/selftests/powerpc/ptrace/Makefile index 4803052..fd896b2 100644 --- a/tools/testing/selftests/powerpc/ptrace/Makefile +++ b/tools/testing/selftests/powerpc/ptrace/Makefile @@ -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-tm-spd-vsx ptrace-tm-spr ptrace-pkey include ../../lib.mk @@ -9,6 +9,9 @@ all: $(TEST_PROGS) CFLAGS += -m64 -I../../../../../usr/include -I../tm -mhtm -fno-pie +ptrace-pkey: ../harness.c ../utils.c ../lib/reg.S ptrace.h ptrace-pkey.c + $(LINK.c) $^ $(LDLIBS) -pthread -o $@ + $(TEST_PROGS): ../harness.c ../utils.c ../lib/reg.S ptrace.h clean: diff --git a/tools/testing/selftests/powerpc/ptrace/ptrace-pkey.c b/tools/testing/selftests/powerpc/ptrace/ptrace-pkey.c new file mode 100644 index 0000000..2e5b676 --- /dev/null +++ b/tools/testing/selftests/powerpc/ptrace/ptrace-pkey.c @@ -0,0 +1,443 @@ +/* + * Ptrace test for Memory Protection Key registers + * + * Copyright (C) 2015 Anshuman Khandual, IBM Corporation. + * Copyright (C) 2017 IBM Corporation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version + * 2 of the License, or (at your option) any later version. + */ +#include +#include "ptrace.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 { + /* 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; + + /* 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, info) \ + do { \ + if ((x)) { \ + fprintf(stderr, \ + "[FAIL] Test FAILED on line %d\n", __LINE__); \ + (info)->child_gave_up = true; \ + prod_parent(info); \ + return 1; \ + } \ + } while (0) + +#define PARENT_FAIL_IF(x, info) \ + do { \ + if ((x)) { \ + fprintf(stderr, \ + "[FAIL] Test FAILED on line %d\n", __LINE__); \ + (info)->parent_gave_up = true; \ + prod_child(info); \ + return 1; \ + } \ + } while (0) + +static int wait_child(struct shared_info *info) +{ + int ret; + + /* Wait until the child prods us. */ + ret = sem_wait(&info->sem_parent); + if (ret) { + perror("Error waiting for child"); + return TEST_FAIL; + } + + return info->child_gave_up ? TEST_FAIL : TEST_PASS; +} + +static int prod_child(struct shared_info *info) +{ + int ret; + + /* Unblock the child now. */ + ret = sem_post(&info->sem_child); + if (ret) { + perror("Error prodding child"); + return TEST_FAIL; + } + + return TEST_PASS; +} + +static int wait_parent(struct shared_info *info) +{ + int ret; + + /* Wait until the parent prods us. */ + ret = sem_wait(&info->sem_child); + if (ret) { + perror("Error waiting for parent"); + return TEST_FAIL; + } + + return info->parent_gave_up ? TEST_FAIL : TEST_PASS; +} + +static int prod_parent(struct shared_info *info) +{ + int ret; + + /* Unblock the parent now. */ + ret = sem_post(&info->sem_parent); + if (ret) { + perror("Error prodding parent"); + return TEST_FAIL; + } + + return TEST_PASS; +} + +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 ptrace_read_regs(pid_t child, 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, NT_PPC_PKEY, &iov); + FAIL_IF(ret != 0); + + FAIL_IF(stop_trace(child)); + + return TEST_PASS; +} + +static long ptrace_write_regs(pid_t child, 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, NT_PPC_PKEY, &iov); + + FAIL_IF(stop_trace(child)); + + return ret; +} + +static int child(struct shared_info *info) +{ + unsigned long reg; + bool disable_execute = true; + int pkey1, pkey2, pkey3; + int 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); + + disable_execute = false; + } + + pkey2 = sys_pkey_alloc(0, 0); + CHILD_FAIL_IF(pkey2 < 0, info); + + pkey3 = sys_pkey_alloc(0, 0); + CHILD_FAIL_IF(pkey3 < 0, info); + + 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); + else + info->expected_iamr = 0; + + 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_FAIL_IF(ret, info); + + ret = wait_parent(info); + if (ret) + return ret; + + reg = mfspr(SPRN_AMR); + + printf("%-30s AMR: %016lx\n", user_read, reg); + + CHILD_FAIL_IF(reg != info->amr2, info); + + /* + * Wait for parent to try to write an invalid AMR value. + */ + ret = prod_parent(info); + CHILD_FAIL_IF(ret, info); + + ret = wait_parent(info); + if (ret) + return ret; + + reg = mfspr(SPRN_AMR); + + printf("%-30s AMR: %016lx\n", user_read, reg); + + CHILD_FAIL_IF(reg != info->amr2, info); + + /* + * 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_FAIL_IF(ret, info); + + ret = wait_parent(info); + if (ret) + return ret; + + reg = mfspr(SPRN_AMR); + + printf("%-30s AMR: %016lx\n", user_read, reg); + + CHILD_FAIL_IF(reg != info->amr2, info); + + /* Now let parent now that we are finished. */ + + ret = prod_parent(info); + CHILD_FAIL_IF(ret, info); + + return TEST_PASS; +} + +static int parent(struct shared_info *info, pid_t pid) +{ + unsigned long regs[4]; + int ret, status; + + ret = wait_child(info); + if (ret) + return ret; + + /* Verify that we can read the pkey registers from the child. */ + ret = ptrace_read_regs(pid, regs, 3); + PARENT_FAIL_IF(ret, info); + + 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); + PARENT_FAIL_IF(regs[1] != info->expected_iamr, info); + PARENT_FAIL_IF(regs[2] != info->expected_uamor, info); + + /* Write valid AMR value in child. */ + ret = ptrace_write_regs(pid, &info->amr2, 1); + PARENT_FAIL_IF(ret, info); + + printf("%-30s AMR: %016lx\n", ptrace_write_running, info->amr2); + + /* Wake up child so that it can verify it changed. */ + ret = prod_child(info); + PARENT_FAIL_IF(ret, info); + + ret = wait_child(info); + if (ret) + return ret; + + /* Write invalid AMR value in child. */ + ret = ptrace_write_regs(pid, &info->amr3, 1); + PARENT_FAIL_IF(ret, info); + + 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); + PARENT_FAIL_IF(ret, info); + + ret = wait_child(info); + if (ret) + return ret; + + /* Try to write to IAMR. */ + regs[0] = info->amr1; + regs[1] = info->new_iamr; + ret = ptrace_write_regs(pid, regs, 2); + PARENT_FAIL_IF(!ret, info); + + 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, regs, 3); + PARENT_FAIL_IF(!ret, info); + + 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, regs, 3); + PARENT_FAIL_IF(ret, info); + + 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); + PARENT_FAIL_IF(regs[1] != info->expected_iamr, info); + PARENT_FAIL_IF(regs[2] != info->expected_uamor, info); + + /* Wake up child so that it can verify AMR didn't change and wrap up. */ + ret = prod_child(info); + PARENT_FAIL_IF(ret, info); + + 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 = sem_init(&info->sem_parent, 1, 0); + if (ret) { + perror("Semaphore initialization failed"); + return TEST_FAIL; + } + ret = sem_init(&info->sem_child, 1, 0); + if (ret) { + perror("Semaphore initialization failed"); + return TEST_FAIL; + } + + 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) { + sem_destroy(&info->sem_parent); + sem_destroy(&info->sem_child); + shmctl(shm_id, IPC_RMID, NULL); + } + + return ret; +} + +int main(int argc, char *argv[]) +{ + return test_harness(ptrace_pkey, "ptrace_pkey"); +}