cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

resets.c (7551B)


      1// SPDX-License-Identifier: GPL-2.0-or-later
      2/*
      3 * Test for s390x CPU resets
      4 *
      5 * Copyright (C) 2020, IBM
      6 */
      7
      8#include <stdio.h>
      9#include <stdlib.h>
     10#include <string.h>
     11#include <sys/ioctl.h>
     12
     13#include "test_util.h"
     14#include "kvm_util.h"
     15
     16#define VCPU_ID 3
     17#define LOCAL_IRQS 32
     18
     19struct kvm_s390_irq buf[VCPU_ID + LOCAL_IRQS];
     20
     21struct kvm_vm *vm;
     22struct kvm_run *run;
     23struct kvm_sync_regs *sync_regs;
     24static uint8_t regs_null[512];
     25
     26static void guest_code_initial(void)
     27{
     28	/* set several CRs to "safe" value */
     29	unsigned long cr2_59 = 0x10;	/* enable guarded storage */
     30	unsigned long cr8_63 = 0x1;	/* monitor mask = 1 */
     31	unsigned long cr10 = 1;		/* PER START */
     32	unsigned long cr11 = -1;	/* PER END */
     33
     34
     35	/* Dirty registers */
     36	asm volatile (
     37		"	lghi	2,0x11\n"	/* Round toward 0 */
     38		"	sfpc	2\n"		/* set fpc to !=0 */
     39		"	lctlg	2,2,%0\n"
     40		"	lctlg	8,8,%1\n"
     41		"	lctlg	10,10,%2\n"
     42		"	lctlg	11,11,%3\n"
     43		/* now clobber some general purpose regs */
     44		"	llihh	0,0xffff\n"
     45		"	llihl	1,0x5555\n"
     46		"	llilh	2,0xaaaa\n"
     47		"	llill	3,0x0000\n"
     48		/* now clobber a floating point reg */
     49		"	lghi	4,0x1\n"
     50		"	cdgbr	0,4\n"
     51		/* now clobber an access reg */
     52		"	sar	9,4\n"
     53		/* We embed diag 501 here to control register content */
     54		"	diag 0,0,0x501\n"
     55		:
     56		: "m" (cr2_59), "m" (cr8_63), "m" (cr10), "m" (cr11)
     57		/* no clobber list as this should not return */
     58		);
     59}
     60
     61static void test_one_reg(uint64_t id, uint64_t value)
     62{
     63	struct kvm_one_reg reg;
     64	uint64_t eval_reg;
     65
     66	reg.addr = (uintptr_t)&eval_reg;
     67	reg.id = id;
     68	vcpu_get_reg(vm, VCPU_ID, &reg);
     69	TEST_ASSERT(eval_reg == value, "value == 0x%lx", value);
     70}
     71
     72static void assert_noirq(void)
     73{
     74	struct kvm_s390_irq_state irq_state;
     75	int irqs;
     76
     77	irq_state.len = sizeof(buf);
     78	irq_state.buf = (unsigned long)buf;
     79	irqs = _vcpu_ioctl(vm, VCPU_ID, KVM_S390_GET_IRQ_STATE, &irq_state);
     80	/*
     81	 * irqs contains the number of retrieved interrupts. Any interrupt
     82	 * (notably, the emergency call interrupt we have injected) should
     83	 * be cleared by the resets, so this should be 0.
     84	 */
     85	TEST_ASSERT(irqs >= 0, "Could not fetch IRQs: errno %d\n", errno);
     86	TEST_ASSERT(!irqs, "IRQ pending");
     87}
     88
     89static void assert_clear(void)
     90{
     91	struct kvm_sregs sregs;
     92	struct kvm_regs regs;
     93	struct kvm_fpu fpu;
     94
     95	vcpu_regs_get(vm, VCPU_ID, &regs);
     96	TEST_ASSERT(!memcmp(&regs.gprs, regs_null, sizeof(regs.gprs)), "grs == 0");
     97
     98	vcpu_sregs_get(vm, VCPU_ID, &sregs);
     99	TEST_ASSERT(!memcmp(&sregs.acrs, regs_null, sizeof(sregs.acrs)), "acrs == 0");
    100
    101	vcpu_fpu_get(vm, VCPU_ID, &fpu);
    102	TEST_ASSERT(!memcmp(&fpu.fprs, regs_null, sizeof(fpu.fprs)), "fprs == 0");
    103
    104	/* sync regs */
    105	TEST_ASSERT(!memcmp(sync_regs->gprs, regs_null, sizeof(sync_regs->gprs)),
    106		    "gprs0-15 == 0 (sync_regs)");
    107
    108	TEST_ASSERT(!memcmp(sync_regs->acrs, regs_null, sizeof(sync_regs->acrs)),
    109		    "acrs0-15 == 0 (sync_regs)");
    110
    111	TEST_ASSERT(!memcmp(sync_regs->vrs, regs_null, sizeof(sync_regs->vrs)),
    112		    "vrs0-15 == 0 (sync_regs)");
    113}
    114
    115static void assert_initial_noclear(void)
    116{
    117	TEST_ASSERT(sync_regs->gprs[0] == 0xffff000000000000UL,
    118		    "gpr0 == 0xffff000000000000 (sync_regs)");
    119	TEST_ASSERT(sync_regs->gprs[1] == 0x0000555500000000UL,
    120		    "gpr1 == 0x0000555500000000 (sync_regs)");
    121	TEST_ASSERT(sync_regs->gprs[2] == 0x00000000aaaa0000UL,
    122		    "gpr2 == 0x00000000aaaa0000 (sync_regs)");
    123	TEST_ASSERT(sync_regs->gprs[3] == 0x0000000000000000UL,
    124		    "gpr3 == 0x0000000000000000 (sync_regs)");
    125	TEST_ASSERT(sync_regs->fprs[0] == 0x3ff0000000000000UL,
    126		    "fpr0 == 0f1 (sync_regs)");
    127	TEST_ASSERT(sync_regs->acrs[9] == 1, "ar9 == 1 (sync_regs)");
    128}
    129
    130static void assert_initial(void)
    131{
    132	struct kvm_sregs sregs;
    133	struct kvm_fpu fpu;
    134
    135	/* KVM_GET_SREGS */
    136	vcpu_sregs_get(vm, VCPU_ID, &sregs);
    137	TEST_ASSERT(sregs.crs[0] == 0xE0UL, "cr0 == 0xE0 (KVM_GET_SREGS)");
    138	TEST_ASSERT(sregs.crs[14] == 0xC2000000UL,
    139		    "cr14 == 0xC2000000 (KVM_GET_SREGS)");
    140	TEST_ASSERT(!memcmp(&sregs.crs[1], regs_null, sizeof(sregs.crs[1]) * 12),
    141		    "cr1-13 == 0 (KVM_GET_SREGS)");
    142	TEST_ASSERT(sregs.crs[15] == 0, "cr15 == 0 (KVM_GET_SREGS)");
    143
    144	/* sync regs */
    145	TEST_ASSERT(sync_regs->crs[0] == 0xE0UL, "cr0 == 0xE0 (sync_regs)");
    146	TEST_ASSERT(sync_regs->crs[14] == 0xC2000000UL,
    147		    "cr14 == 0xC2000000 (sync_regs)");
    148	TEST_ASSERT(!memcmp(&sync_regs->crs[1], regs_null, 8 * 12),
    149		    "cr1-13 == 0 (sync_regs)");
    150	TEST_ASSERT(sync_regs->crs[15] == 0, "cr15 == 0 (sync_regs)");
    151	TEST_ASSERT(sync_regs->fpc == 0, "fpc == 0 (sync_regs)");
    152	TEST_ASSERT(sync_regs->todpr == 0, "todpr == 0 (sync_regs)");
    153	TEST_ASSERT(sync_regs->cputm == 0, "cputm == 0 (sync_regs)");
    154	TEST_ASSERT(sync_regs->ckc == 0, "ckc == 0 (sync_regs)");
    155	TEST_ASSERT(sync_regs->pp == 0, "pp == 0 (sync_regs)");
    156	TEST_ASSERT(sync_regs->gbea == 1, "gbea == 1 (sync_regs)");
    157
    158	/* kvm_run */
    159	TEST_ASSERT(run->psw_addr == 0, "psw_addr == 0 (kvm_run)");
    160	TEST_ASSERT(run->psw_mask == 0, "psw_mask == 0 (kvm_run)");
    161
    162	vcpu_fpu_get(vm, VCPU_ID, &fpu);
    163	TEST_ASSERT(!fpu.fpc, "fpc == 0");
    164
    165	test_one_reg(KVM_REG_S390_GBEA, 1);
    166	test_one_reg(KVM_REG_S390_PP, 0);
    167	test_one_reg(KVM_REG_S390_TODPR, 0);
    168	test_one_reg(KVM_REG_S390_CPU_TIMER, 0);
    169	test_one_reg(KVM_REG_S390_CLOCK_COMP, 0);
    170}
    171
    172static void assert_normal_noclear(void)
    173{
    174	TEST_ASSERT(sync_regs->crs[2] == 0x10, "cr2 == 10 (sync_regs)");
    175	TEST_ASSERT(sync_regs->crs[8] == 1, "cr10 == 1 (sync_regs)");
    176	TEST_ASSERT(sync_regs->crs[10] == 1, "cr10 == 1 (sync_regs)");
    177	TEST_ASSERT(sync_regs->crs[11] == -1, "cr11 == -1 (sync_regs)");
    178}
    179
    180static void assert_normal(void)
    181{
    182	test_one_reg(KVM_REG_S390_PFTOKEN, KVM_S390_PFAULT_TOKEN_INVALID);
    183	TEST_ASSERT(sync_regs->pft == KVM_S390_PFAULT_TOKEN_INVALID,
    184			"pft == 0xff.....  (sync_regs)");
    185	assert_noirq();
    186}
    187
    188static void inject_irq(int cpu_id)
    189{
    190	struct kvm_s390_irq_state irq_state;
    191	struct kvm_s390_irq *irq = &buf[0];
    192	int irqs;
    193
    194	/* Inject IRQ */
    195	irq_state.len = sizeof(struct kvm_s390_irq);
    196	irq_state.buf = (unsigned long)buf;
    197	irq->type = KVM_S390_INT_EMERGENCY;
    198	irq->u.emerg.code = cpu_id;
    199	irqs = _vcpu_ioctl(vm, cpu_id, KVM_S390_SET_IRQ_STATE, &irq_state);
    200	TEST_ASSERT(irqs >= 0, "Error injecting EMERGENCY IRQ errno %d\n", errno);
    201}
    202
    203static void test_normal(void)
    204{
    205	pr_info("Testing normal reset\n");
    206	/* Create VM */
    207	vm = vm_create_default(VCPU_ID, 0, guest_code_initial);
    208	run = vcpu_state(vm, VCPU_ID);
    209	sync_regs = &run->s.regs;
    210
    211	vcpu_run(vm, VCPU_ID);
    212
    213	inject_irq(VCPU_ID);
    214
    215	vcpu_ioctl(vm, VCPU_ID, KVM_S390_NORMAL_RESET, 0);
    216
    217	/* must clears */
    218	assert_normal();
    219	/* must not clears */
    220	assert_normal_noclear();
    221	assert_initial_noclear();
    222
    223	kvm_vm_free(vm);
    224}
    225
    226static void test_initial(void)
    227{
    228	pr_info("Testing initial reset\n");
    229	vm = vm_create_default(VCPU_ID, 0, guest_code_initial);
    230	run = vcpu_state(vm, VCPU_ID);
    231	sync_regs = &run->s.regs;
    232
    233	vcpu_run(vm, VCPU_ID);
    234
    235	inject_irq(VCPU_ID);
    236
    237	vcpu_ioctl(vm, VCPU_ID, KVM_S390_INITIAL_RESET, 0);
    238
    239	/* must clears */
    240	assert_normal();
    241	assert_initial();
    242	/* must not clears */
    243	assert_initial_noclear();
    244
    245	kvm_vm_free(vm);
    246}
    247
    248static void test_clear(void)
    249{
    250	pr_info("Testing clear reset\n");
    251	vm = vm_create_default(VCPU_ID, 0, guest_code_initial);
    252	run = vcpu_state(vm, VCPU_ID);
    253	sync_regs = &run->s.regs;
    254
    255	vcpu_run(vm, VCPU_ID);
    256
    257	inject_irq(VCPU_ID);
    258
    259	vcpu_ioctl(vm, VCPU_ID, KVM_S390_CLEAR_RESET, 0);
    260
    261	/* must clears */
    262	assert_normal();
    263	assert_initial();
    264	assert_clear();
    265
    266	kvm_vm_free(vm);
    267}
    268
    269int main(int argc, char *argv[])
    270{
    271	setbuf(stdout, NULL);	/* Tell stdout not to buffer its content */
    272
    273	test_initial();
    274	if (kvm_check_cap(KVM_CAP_S390_VCPU_RESETS)) {
    275		test_normal();
    276		test_clear();
    277	}
    278	return 0;
    279}