Quelle  check_gcr_el1_cswitch.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
// Copyright (C) 2020 ARM Limited

#define _GNU_SOURCE

#include <errno.h>
#include <pthread.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <sys/auxv.h>
#include <sys/mman.h>
#include <sys/prctl.h>
#include <sys/types.h>
#include <sys/wait.h>

#include "kselftest.h"
#include "mte_common_util.h"

#include "mte_def.h"

#define NUM_ITERATIONS  1024
#define MAX_THREADS  5
#define THREAD_ITERATIONS 1000

void *execute_thread(void *x)
{
 pid_t pid = *((pid_t *)x);
 pid_t tid = gettid();
 uint64_t prctl_tag_mask;
 uint64_t prctl_set;
 uint64_t prctl_get;
 uint64_t prctl_tcf;

 srand(time(NULL) ^ (pid << 16) ^ (tid << 16));

 prctl_tag_mask = rand() & 0xffff;

 if (prctl_tag_mask % 2)
  prctl_tcf = PR_MTE_TCF_SYNC;
 else
  prctl_tcf = PR_MTE_TCF_ASYNC;

 prctl_set = PR_TAGGED_ADDR_ENABLE | prctl_tcf | (prctl_tag_mask << PR_MTE_TAG_SHIFT);

 for (int j = 0; j < THREAD_ITERATIONS; j++) {
  if (prctl(PR_SET_TAGGED_ADDR_CTRL, prctl_set, 0, 0, 0)) {
   perror("prctl() failed");
   goto fail;
  }

  prctl_get = prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0);

  if (prctl_set != prctl_get) {
   ksft_print_msg("Error: prctl_set: 0x%lx != prctl_get: 0x%lx\n",
      prctl_set, prctl_get);
   goto fail;
  }
 }

 return (void *)KSFT_PASS;

fail:
 return (void *)KSFT_FAIL;
}

int execute_test(pid_t pid)
{
 pthread_t thread_id[MAX_THREADS];
 int thread_data[MAX_THREADS];

 for (int i = 0; i < MAX_THREADS; i++)
  pthread_create(&thread_id[i], NULL,
          execute_thread, (void *)&pid);

 for (int i = 0; i < MAX_THREADS; i++)
  pthread_join(thread_id[i], (void *)&thread_data[i]);

 for (int i = 0; i < MAX_THREADS; i++)
  if (thread_data[i] == KSFT_FAIL)
   return KSFT_FAIL;

 return KSFT_PASS;
}

int mte_gcr_fork_test(void)
{
 pid_t pid;
 int results[NUM_ITERATIONS];
 pid_t cpid;
 int res;

 for (int i = 0; i < NUM_ITERATIONS; i++) {
  pid = fork();

  if (pid < 0)
   return KSFT_FAIL;

  if (pid == 0) {
   cpid = getpid();

   res = execute_test(cpid);

   exit(res);
  }
 }

 for (int i = 0; i < NUM_ITERATIONS; i++) {
  wait(&res);

  if (WIFEXITED(res))
   results[i] = WEXITSTATUS(res);
  else
   --i;
 }

 for (int i = 0; i < NUM_ITERATIONS; i++)
  if (results[i] == KSFT_FAIL)
   return KSFT_FAIL;

 return KSFT_PASS;
}

int main(int argc, char *argv[])
{
 int err;

 err = mte_default_setup();
 if (err)
  return err;

 ksft_set_plan(1);

 evaluate_test(mte_gcr_fork_test(),
  "Verify that GCR_EL1 is set correctly on context switch\n");

 mte_restore_setup();
 ksft_print_cnts();

 return ksft_get_fail_cnt() == 0 ? KSFT_PASS : KSFT_FAIL;
}