Quelle  ptrace-pkey.c   Sprache: C

// 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"
#include "pkeys.h"

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 invalid_amr;

 /* 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 invalid_iamr;
 unsigned long invalid_uamor;
};

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, PKEY_UNRESTRICTED);
  CHILD_FAIL_IF(pkey1 < 0, &info->child_sync);

  disable_execute = false;
 }

 pkey2 = sys_pkey_alloc(0, PKEY_UNRESTRICTED);
 CHILD_FAIL_IF(pkey2 < 0, &info->child_sync);

 pkey3 = sys_pkey_alloc(0, PKEY_UNRESTRICTED);
 CHILD_FAIL_IF(pkey3 < 0, &info->child_sync);

 info->amr1 |= 3ul << pkeyshift(pkey1);
 info->amr2 |= 3ul << pkeyshift(pkey2);
 /*
 * invalid amr value where we try to force write
 * things which are deined by a uamor setting.
 */
 info->invalid_amr = info->amr2 | (~0x0UL & ~info->expected_uamor);

 /*
 * if PKEY_DISABLE_EXECUTE succeeded we should update the expected_iamr
 */
 if (disable_execute)
  info->expected_iamr |= 1ul << pkeyshift(pkey1);
 else
  info->expected_iamr &= ~(1ul << pkeyshift(pkey1));

 /*
 * We allocated pkey2 and pkey 3 above. Clear the IAMR bits.
 */
 info->expected_iamr &= ~(1ul << pkeyshift(pkey2));
 info->expected_iamr &= ~(1ul << pkeyshift(pkey3));

 /*
 * Create an IAMR value different from expected value.
 * Kernel will reject an IAMR and UAMOR change.
 */
 info->invalid_iamr = info->expected_iamr | (1ul << pkeyshift(pkey1) | 1ul << pkeyshift(pkey2));
 info->invalid_uamor = info->expected_uamor & ~(0x3ul << pkeyshift(pkey1));

 printf("%-30s AMR: %016lx pkey1: %d pkey2: %d pkey3: %d\n",
        user_write, info->amr1, pkey1, pkey2, pkey3);

 set_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, "PKEYs not supported");
 PARENT_FAIL_IF(ret, &info->child_sync);

 info->amr1 = info->amr2 = regs[0];
 info->expected_iamr = regs[1];
 info->expected_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->invalid_amr, 1);
 PARENT_FAIL_IF(ret, &info->child_sync);

 printf("%-30s AMR: %016lx\n", ptrace_write_running, info->invalid_amr);

 /* 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->invalid_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->invalid_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");
}