Quelle  core-pkey.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 <limits.h>
#include <linux/kernel.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <fcntl.h>
#include <unistd.h>
#include "ptrace.h"
#include "child.h"
#include "pkeys.h"

#define CORE_FILE_LIMIT (5 * 1024 * 1024) /* 5 MB should be enough */

static const char core_pattern_file[] = "/proc/sys/kernel/core_pattern";

static const char user_write[] = "[User Write (Running)]";
static const char core_read_running[] = "[Core Read (Running)]";

/* Information shared between the parent and the child. */
struct shared_info {
 struct child_sync child_sync;

 /* AMR value the parent expects to read in the core file. */
 unsigned long amr;

 /* IAMR value the parent expects to read in the core file. */
 unsigned long iamr;

 /* UAMOR value the parent expects to read in the core file. */
 unsigned long uamor;

 /* When the child crashed. */
 time_t core_time;
};

static int increase_core_file_limit(void)
{
 struct rlimit rlim;
 int ret;

 ret = getrlimit(RLIMIT_CORE, &rlim);
 FAIL_IF(ret);

 if (rlim.rlim_cur != RLIM_INFINITY && rlim.rlim_cur < CORE_FILE_LIMIT) {
  rlim.rlim_cur = CORE_FILE_LIMIT;

  if (rlim.rlim_max != RLIM_INFINITY &&
      rlim.rlim_max < CORE_FILE_LIMIT)
   rlim.rlim_max = CORE_FILE_LIMIT;

  ret = setrlimit(RLIMIT_CORE, &rlim);
  FAIL_IF(ret);
 }

 ret = getrlimit(RLIMIT_FSIZE, &rlim);
 FAIL_IF(ret);

 if (rlim.rlim_cur != RLIM_INFINITY && rlim.rlim_cur < CORE_FILE_LIMIT) {
  rlim.rlim_cur = CORE_FILE_LIMIT;

  if (rlim.rlim_max != RLIM_INFINITY &&
      rlim.rlim_max < CORE_FILE_LIMIT)
   rlim.rlim_max = CORE_FILE_LIMIT;

  ret = setrlimit(RLIMIT_FSIZE, &rlim);
  FAIL_IF(ret);
 }

 return TEST_PASS;
}

static int child(struct shared_info *info)
{
 bool disable_execute = true;
 int pkey1, pkey2, pkey3;
 int *ptr, ret;

 /* Wait until parent fills out the initial register values. */
 ret = wait_parent(&info->child_sync);
 if (ret)
  return ret;

 ret = increase_core_file_limit();
 FAIL_IF(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);
  FAIL_IF(pkey1 < 0);

  disable_execute = false;
 }

 pkey2 = sys_pkey_alloc(0, PKEY_UNRESTRICTED);
 FAIL_IF(pkey2 < 0);

 pkey3 = sys_pkey_alloc(0, PKEY_UNRESTRICTED);
 FAIL_IF(pkey3 < 0);

 info->amr |= 3ul << pkeyshift(pkey1) | 2ul << pkeyshift(pkey2);

 if (disable_execute)
  info->iamr |= 1ul << pkeyshift(pkey1);
 else
  info->iamr &= ~(1ul << pkeyshift(pkey1));

 info->iamr &= ~(1ul << pkeyshift(pkey2) | 1ul << pkeyshift(pkey3));

 info->uamor |= 3ul << pkeyshift(pkey1) | 3ul << pkeyshift(pkey2);

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

 set_amr(info->amr);

 /*
 * We won't use pkey3. This tests whether the kernel restores the UAMOR
 * permissions after a key is freed.
 */
 sys_pkey_free(pkey3);

 info->core_time = time(NULL);

 /* Crash. */
 ptr = 0;
 *ptr = 1;

 /* Shouldn't get here. */
 FAIL_IF(true);

 return TEST_FAIL;
}

/* Return file size if filename exists and pass sanity check, or zero if not. */
static off_t try_core_file(const char *filename, struct shared_info *info,
      pid_t pid)
{
 struct stat buf;
 int ret;

 ret = stat(filename, &buf);
 if (ret == -1)
  return TEST_FAIL;

 /* Make sure we're not using a stale core file. */
 return buf.st_mtime >= info->core_time ? buf.st_size : TEST_FAIL;
}

static Elf64_Nhdr *next_note(Elf64_Nhdr *nhdr)
{
 return (void *) nhdr + sizeof(*nhdr) +
  __ALIGN_KERNEL(nhdr->n_namesz, 4) +
  __ALIGN_KERNEL(nhdr->n_descsz, 4);
}

static int check_core_file(struct shared_info *info, Elf64_Ehdr *ehdr,
      off_t core_size)
{
 unsigned long *regs;
 Elf64_Phdr *phdr;
 Elf64_Nhdr *nhdr;
 size_t phdr_size;
 void *p = ehdr, *note;
 int ret;

 ret = memcmp(ehdr->e_ident, ELFMAG, SELFMAG);
 FAIL_IF(ret);

 FAIL_IF(ehdr->e_type != ET_CORE);
 FAIL_IF(ehdr->e_machine != EM_PPC64);
 FAIL_IF(ehdr->e_phoff == 0 || ehdr->e_phnum == 0);

 /*
 * e_phnum is at most 65535 so calculating the size of the
 * program header cannot overflow.
 */
 phdr_size = sizeof(*phdr) * ehdr->e_phnum;

 /* Sanity check the program header table location. */
 FAIL_IF(ehdr->e_phoff + phdr_size < ehdr->e_phoff);
 FAIL_IF(ehdr->e_phoff + phdr_size > core_size);

 /* Find the PT_NOTE segment. */
 for (phdr = p + ehdr->e_phoff;
      (void *) phdr < p + ehdr->e_phoff + phdr_size;
      phdr += ehdr->e_phentsize)
  if (phdr->p_type == PT_NOTE)
   break;

 FAIL_IF((void *) phdr >= p + ehdr->e_phoff + phdr_size);

 /* Find the NT_PPC_PKEY note. */
 for (nhdr = p + phdr->p_offset;
      (void *) nhdr < p + phdr->p_offset + phdr->p_filesz;
      nhdr = next_note(nhdr))
  if (nhdr->n_type == NT_PPC_PKEY)
   break;

 FAIL_IF((void *) nhdr >= p + phdr->p_offset + phdr->p_filesz);
 FAIL_IF(nhdr->n_descsz == 0);

 p = nhdr;
 note = p + sizeof(*nhdr) + __ALIGN_KERNEL(nhdr->n_namesz, 4);

 regs = (unsigned long *) note;

 printf("%-30s AMR: %016lx IAMR: %016lx UAMOR: %016lx\n",
        core_read_running, regs[0], regs[1], regs[2]);

 FAIL_IF(regs[0] != info->amr);
 FAIL_IF(regs[1] != info->iamr);
 FAIL_IF(regs[2] != info->uamor);

 return TEST_PASS;
}

static int parent(struct shared_info *info, pid_t pid)
{
 char *filenames, *filename[3];
 int fd, i, ret, status;
 unsigned long regs[3];
 off_t core_size;
 void *core;

 /*
 * 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->amr = regs[0];
 info->iamr = regs[1];
 info->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(&status);
 if (ret != pid) {
  printf("Child's exit status not captured\n");
  return TEST_FAIL;
 } else if (!WIFSIGNALED(status) || !WCOREDUMP(status)) {
  printf("Child didn't dump core\n");
  return TEST_FAIL;
 }

 /* Construct array of core file names to try. */

 filename[0] = filenames = malloc(PATH_MAX);
 if (!filenames) {
  perror("Error allocating memory");
  return TEST_FAIL;
 }

 ret = snprintf(filename[0], PATH_MAX, "core-pkey.%d", pid);
 if (ret < 0 || ret >= PATH_MAX) {
  ret = TEST_FAIL;
  goto out;
 }

 filename[1] = filename[0] + ret + 1;
 ret = snprintf(filename[1], PATH_MAX - ret - 1, "core.%d", pid);
 if (ret < 0 || ret >= PATH_MAX - ret - 1) {
  ret = TEST_FAIL;
  goto out;
 }
 filename[2] = "core";

 for (i = 0; i < 3; i++) {
  core_size = try_core_file(filename[i], info, pid);
  if (core_size != TEST_FAIL)
   break;
 }

 if (i == 3) {
  printf("Couldn't find core file\n");
  ret = TEST_FAIL;
  goto out;
 }

 fd = open(filename[i], O_RDONLY);
 if (fd == -1) {
  perror("Error opening core file");
  ret = TEST_FAIL;
  goto out;
 }

 core = mmap(NULL, core_size, PROT_READ, MAP_PRIVATE, fd, 0);
 if (core == (void *) -1) {
  perror("Error mmapping core file");
  ret = TEST_FAIL;
  goto out;
 }

 ret = check_core_file(info, core, core_size);

 munmap(core, core_size);
 close(fd);
 unlink(filename[i]);

 out:
 free(filenames);

 return ret;
}

static int write_core_pattern(const char *core_pattern)
{
 int err;

 err = write_file(core_pattern_file, core_pattern, strlen(core_pattern));
 if (err) {
  SKIP_IF_MSG(err == -EPERM, "Try with root privileges");
  perror("Error writing to core_pattern file");
  return TEST_FAIL;
 }

 return TEST_PASS;
}

static int setup_core_pattern(char **core_pattern_, bool *changed_)
{
 char *core_pattern;
 size_t len;
 int ret;

 core_pattern = malloc(PATH_MAX);
 if (!core_pattern) {
  perror("Error allocating memory");
  return TEST_FAIL;
 }

 ret = read_file(core_pattern_file, core_pattern, PATH_MAX - 1, &len);
 if (ret) {
  perror("Error reading core_pattern file");
  ret = TEST_FAIL;
  goto out;
 }

 core_pattern[len] = '\0';

 /* Check whether we can predict the name of the core file. */
 if (!strcmp(core_pattern, "core") || !strcmp(core_pattern, "core.%p"))
  *changed_ = false;
 else {
  ret = write_core_pattern("core-pkey.%p");
  if (ret)
   goto out;

  *changed_ = true;
 }

 *core_pattern_ = core_pattern;
 ret = TEST_PASS;

 out:
 if (ret)
  free(core_pattern);

 return ret;
}

static int core_pkey(void)
{
 char *core_pattern;
 bool changed_core_pattern;
 struct shared_info *info;
 int shm_id;
 int ret;
 pid_t pid;

 ret = setup_core_pattern(&core_pattern, &changed_core_pattern);
 if (ret)
  return ret;

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

  if (changed_core_pattern)
   write_core_pattern(core_pattern);
 }

 free(core_pattern);

 return ret;
}

int main(int argc, char *argv[])
{
 return test_harness(core_pkey, "core_pkey");
}