Quelle  test.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2019,2021  Arm Limited
 * Original author: Dave Martin <Dave.Martin@arm.com>
 */

#include "system.h"

#include <stdbool.h>
#include <stddef.h>
#include <linux/errno.h>
#include <linux/auxvec.h>
#include <linux/signal.h>
#include <asm/sigcontext.h>
#include <asm/ucontext.h>

typedef struct ucontext ucontext_t;

#include "btitest.h"
#include "signal.h"

#define EXPECTED_TESTS 18

static volatile unsigned int test_num = 1;
static unsigned int test_passed;
static unsigned int test_failed;
static unsigned int test_skipped;

static void fdputs(int fd, const char *str)
{
 size_t len = 0;
 const char *p = str;

 while (*p++)
  ++len;

 write(fd, str, len);
}

static void putstr(const char *str)
{
 fdputs(1, str);
}

static void putnum(unsigned int num)
{
 char c;

 if (num / 10)
  putnum(num / 10);

 c = '0' + (num % 10);
 write(1, &c, 1);
}

#define puttestname(test_name, trampoline_name) do { \
 putstr(test_name);    \
 putstr("/");     \
 putstr(trampoline_name);   \
} while (0)

void print_summary(void)
{
 putstr("# Totals: pass:");
 putnum(test_passed);
 putstr(" fail:");
 putnum(test_failed);
 putstr(" xfail:0 xpass:0 skip:");
 putnum(test_skipped);
 putstr(" error:0\n");
}

static const char *volatile current_test_name;
static const char *volatile current_trampoline_name;
static volatile int sigill_expected, sigill_received;

static void handler(int n, siginfo_t *si __always_unused,
      void *uc_ __always_unused)
{
 ucontext_t *uc = uc_;

 putstr("# \t[SIGILL in ");
 puttestname(current_test_name, current_trampoline_name);
 putstr(", BTYPE=");
 write(1, &"00011011"[((uc->uc_mcontext.pstate & PSR_BTYPE_MASK)
         >> PSR_BTYPE_SHIFT) * 2], 2);
 if (!sigill_expected) {
  putstr("]\n");
  putstr("not ok ");
  putnum(test_num);
  putstr(" ");
  puttestname(current_test_name, current_trampoline_name);
  putstr("(unexpected SIGILL)\n");
  print_summary();
  exit(128 + n);
 }

 putstr(" (expected)]\n");
 sigill_received = 1;
 /* zap BTYPE so that resuming the faulting code will work */
 uc->uc_mcontext.pstate &= ~PSR_BTYPE_MASK;
}

/* Does the system have BTI? */
static bool have_bti;

static void __do_test(void (*trampoline)(void (*)(void)),
        void (*fn)(void),
        const char *trampoline_name,
        const char *name,
        int expect_sigill)
{
 /*
 * Branch Target exceptions should only happen for BTI
 * binaries running on a system with BTI:
 */
 if (!BTI || !have_bti)
  expect_sigill = 0;

 sigill_expected = expect_sigill;
 sigill_received = 0;
 current_test_name = name;
 current_trampoline_name = trampoline_name;

 trampoline(fn);

 if (expect_sigill && !sigill_received) {
  putstr("not ok ");
  test_failed++;
 } else {
  putstr("ok ");
  test_passed++;
 }
 putnum(test_num++);
 putstr(" ");
 puttestname(name, trampoline_name);
 putstr("\n");
}

#define do_test(expect_sigill_br_x0,     \
  expect_sigill_br_x16,     \
  expect_sigill_blr,     \
  name)       \
do {         \
 __do_test(call_using_br_x0, name, "call_using_br_x0", #name, \
    expect_sigill_br_x0);     \
 __do_test(call_using_br_x16, name, "call_using_br_x16", #name, \
    expect_sigill_br_x16);    \
 __do_test(call_using_blr, name, "call_using_blr", #name, \
    expect_sigill_blr);     \
} while (0)

void start(int *argcp)
{
 struct sigaction sa;
 void *const *p;
 const struct auxv_entry {
  unsigned long type;
  unsigned long val;
 } *auxv;
 unsigned long hwcap = 0, hwcap2 = 0;

 putstr("TAP version 13\n");
 putstr("1..");
 putnum(EXPECTED_TESTS);
 putstr("\n");

 /* Gross hack for finding AT_HWCAP2 from the initial process stack: */
 p = (void *const *)argcp + 1 + *argcp + 1; /* start of environment */
 /* step over environment */
 while (*p++)
  ;
 for (auxv = (const struct auxv_entry *)p; auxv->type != AT_NULL; ++auxv) {
  switch (auxv->type) {
  case AT_HWCAP:
   hwcap = auxv->val;
   break;
  case AT_HWCAP2:
   hwcap2 = auxv->val;
   break;
  default:
   break;
  }
 }

 if (hwcap & HWCAP_PACA)
  putstr("# HWCAP_PACA present\n");
 else
  putstr("# HWCAP_PACA not present\n");

 if (hwcap2 & HWCAP2_BTI) {
  putstr("# HWCAP2_BTI present\n");
  if (!(hwcap & HWCAP_PACA))
   putstr("# Bad hardware? Expect problems.\n");
  have_bti = true;
 } else {
  putstr("# HWCAP2_BTI not present\n");
  have_bti = false;
 }

 putstr("# Test binary");
 if (!BTI)
  putstr(" not");
 putstr(" built for BTI\n");

 sa.sa_handler = (sighandler_t)(void *)handler;
 sa.sa_flags = SA_SIGINFO;
 sigemptyset(&sa.sa_mask);
 sigaction(SIGILL, &sa, NULL);
 sigaddset(&sa.sa_mask, SIGILL);
 sigprocmask(SIG_UNBLOCK, &sa.sa_mask, NULL);

 do_test(1, 1, 1, nohint_func);
 do_test(1, 1, 1, bti_none_func);
 do_test(1, 0, 0, bti_c_func);
 do_test(0, 0, 1, bti_j_func);
 do_test(0, 0, 0, bti_jc_func);
 do_test(1, 0, 0, paciasp_func);

 print_summary();

 if (test_num - 1 != EXPECTED_TESTS)
  putstr("# WARNING - EXPECTED TEST COUNT WRONG\n");

 if (test_failed)
  exit(1);
 else
  exit(0);
}