KVM: s390: Fix, test and feature for 5.18 part 2
- memop selftest - fix SCK locking - adapter interruptions virtualization for secure guests -----BEGIN PGP SIGNATURE----- iQIzBAABCAAdFiEE+SKTgaM0CPnbq/vKEXu8gLWmHHwFAmIvW8IACgkQEXu8gLWm HHx4Bw/+PgXvGCbrxnOL2Y7zzIRrniFag1cPcxNXCjWAH4UnzU9u+5MJ0PpM4119 S+Ch8b+fScXpjBmDkLhjsmm4MlVMZ6/1DpbB+XmalSqDEimLAigbT+7+xViCpLja jajMbIIFUhcmcSjIz47jbtDDeKvBvCD8O7J0nP5fMFV2hxpm9or5JW89BIuJRJiE jrfG4T3FhCTVH0wpWtZm6suJMJ/SjQ9d8LD6e2i5Fx+1OVMpDJF9umnAVwBMyiKN uCbAkMftMmTXYhFwM2CWS65QoWTpDNSYoln1sxNpDgapoQxw+3kAYyMSz0tVMElY yRTBJ3HoIZAyW0bzaK4BSF2bbiewcZqI3o2LMPBIlBCvJaRzJsbH48l02lWsAT3S iO3i4ZpHQLNgOdT1G7w0Xk5XaUCCtWVPSqvjy79u5L5YALKf1DZaW6vgHUQeeHpA oogVE5hjDZof0F5Uuve3lqNh8UhC9CYRVcGkSooFZ12Yf/dsWrUWQe0c5hij+hGH 3lWK7KfNwK18X0QBntg7gzsuc+cO4smTNb20ILsK3n1CvDrWtlpxnY/F8mT9fVxp sUybn+1FD0LA06E7i13rM+a2b0XAsqvGtlA94nt1WtuyshdBsufyhKg7To9+KAUe YMKhZriwdls+/BXSYNlE6nxMmCkmfciMVFiz6LW2e29V5WArydU= =cjy5 -----END PGP SIGNATURE----- Merge tag 'kvm-s390-next-5.18-2' of https://git.kernel.org/pub/scm/linux/kernel/git/kvms390/linux into HEAD KVM: s390: Fix, test and feature for 5.18 part 2 - memop selftest - fix SCK locking - adapter interruptions virtualization for secure guests
This commit is contained in:
Paolo Bonzini
commit
3b53f5535d
@ -80,6 +80,7 @@ enum uv_cmds_inst {
|
||||
|
||||
enum uv_feat_ind {
|
||||
BIT_UV_FEAT_MISC = 0,
|
||||
BIT_UV_FEAT_AIV = 1,
|
||||
};
|
||||
|
||||
struct uv_cb_header {
|
||||
|
||||
@ -1901,13 +1901,12 @@ static int __inject_io(struct kvm *kvm, struct kvm_s390_interrupt_info *inti)
|
||||
isc = int_word_to_isc(inti->io.io_int_word);
|
||||
|
||||
/*
|
||||
* Do not make use of gisa in protected mode. We do not use the lock
|
||||
* checking variant as this is just a performance optimization and we
|
||||
* do not hold the lock here. This is ok as the code will pick
|
||||
* interrupts from both "lists" for delivery.
|
||||
* We do not use the lock checking variant as this is just a
|
||||
* performance optimization and we do not hold the lock here.
|
||||
* This is ok as the code will pick interrupts from both "lists"
|
||||
* for delivery.
|
||||
*/
|
||||
if (!kvm_s390_pv_get_handle(kvm) &&
|
||||
gi->origin && inti->type & KVM_S390_INT_IO_AI_MASK) {
|
||||
if (gi->origin && inti->type & KVM_S390_INT_IO_AI_MASK) {
|
||||
VM_EVENT(kvm, 4, "%s isc %1u", "inject: I/O (AI/gisa)", isc);
|
||||
gisa_set_ipm_gisc(gi->origin, isc);
|
||||
kfree(inti);
|
||||
@ -3171,9 +3170,33 @@ void kvm_s390_gisa_init(struct kvm *kvm)
|
||||
VM_EVENT(kvm, 3, "gisa 0x%pK initialized", gi->origin);
|
||||
}
|
||||
|
||||
void kvm_s390_gisa_enable(struct kvm *kvm)
|
||||
{
|
||||
struct kvm_s390_gisa_interrupt *gi = &kvm->arch.gisa_int;
|
||||
struct kvm_vcpu *vcpu;
|
||||
unsigned long i;
|
||||
u32 gisa_desc;
|
||||
|
||||
if (gi->origin)
|
||||
return;
|
||||
kvm_s390_gisa_init(kvm);
|
||||
gisa_desc = kvm_s390_get_gisa_desc(kvm);
|
||||
if (!gisa_desc)
|
||||
return;
|
||||
kvm_for_each_vcpu(i, vcpu, kvm) {
|
||||
mutex_lock(&vcpu->mutex);
|
||||
vcpu->arch.sie_block->gd = gisa_desc;
|
||||
vcpu->arch.sie_block->eca |= ECA_AIV;
|
||||
VCPU_EVENT(vcpu, 3, "AIV gisa format-%u enabled for cpu %03u",
|
||||
vcpu->arch.sie_block->gd & 0x3, vcpu->vcpu_id);
|
||||
mutex_unlock(&vcpu->mutex);
|
||||
}
|
||||
}
|
||||
|
||||
void kvm_s390_gisa_destroy(struct kvm *kvm)
|
||||
{
|
||||
struct kvm_s390_gisa_interrupt *gi = &kvm->arch.gisa_int;
|
||||
struct kvm_s390_gisa *gisa = gi->origin;
|
||||
|
||||
if (!gi->origin)
|
||||
return;
|
||||
@ -3184,6 +3207,25 @@ void kvm_s390_gisa_destroy(struct kvm *kvm)
|
||||
cpu_relax();
|
||||
hrtimer_cancel(&gi->timer);
|
||||
gi->origin = NULL;
|
||||
VM_EVENT(kvm, 3, "gisa 0x%pK destroyed", gisa);
|
||||
}
|
||||
|
||||
void kvm_s390_gisa_disable(struct kvm *kvm)
|
||||
{
|
||||
struct kvm_s390_gisa_interrupt *gi = &kvm->arch.gisa_int;
|
||||
struct kvm_vcpu *vcpu;
|
||||
unsigned long i;
|
||||
|
||||
if (!gi->origin)
|
||||
return;
|
||||
kvm_for_each_vcpu(i, vcpu, kvm) {
|
||||
mutex_lock(&vcpu->mutex);
|
||||
vcpu->arch.sie_block->eca &= ~ECA_AIV;
|
||||
vcpu->arch.sie_block->gd = 0U;
|
||||
mutex_unlock(&vcpu->mutex);
|
||||
VCPU_EVENT(vcpu, 3, "AIV disabled for cpu %03u", vcpu->vcpu_id);
|
||||
}
|
||||
kvm_s390_gisa_destroy(kvm);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -2195,6 +2195,9 @@ static int kvm_s390_cpus_from_pv(struct kvm *kvm, u16 *rcp, u16 *rrcp)
|
||||
}
|
||||
mutex_unlock(&vcpu->mutex);
|
||||
}
|
||||
/* Ensure that we re-enable gisa if the non-PV guest used it but the PV guest did not. */
|
||||
if (use_gisa)
|
||||
kvm_s390_gisa_enable(kvm);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -2206,6 +2209,10 @@ static int kvm_s390_cpus_to_pv(struct kvm *kvm, u16 *rc, u16 *rrc)
|
||||
|
||||
struct kvm_vcpu *vcpu;
|
||||
|
||||
/* Disable the GISA if the ultravisor does not support AIV. */
|
||||
if (!test_bit_inv(BIT_UV_FEAT_AIV, &uv_info.uv_feature_indications))
|
||||
kvm_s390_gisa_disable(kvm);
|
||||
|
||||
kvm_for_each_vcpu(i, vcpu, kvm) {
|
||||
mutex_lock(&vcpu->mutex);
|
||||
r = kvm_s390_pv_create_cpu(vcpu, rc, rrc);
|
||||
@ -3350,9 +3357,7 @@ int kvm_arch_vcpu_create(struct kvm_vcpu *vcpu)
|
||||
|
||||
vcpu->arch.sie_block->icpua = vcpu->vcpu_id;
|
||||
spin_lock_init(&vcpu->arch.local_int.lock);
|
||||
vcpu->arch.sie_block->gd = (u32)(u64)vcpu->kvm->arch.gisa_int.origin;
|
||||
if (vcpu->arch.sie_block->gd && sclp.has_gisaf)
|
||||
vcpu->arch.sie_block->gd |= GISA_FORMAT1;
|
||||
vcpu->arch.sie_block->gd = kvm_s390_get_gisa_desc(vcpu->kvm);
|
||||
seqcount_init(&vcpu->arch.cputm_seqcount);
|
||||
|
||||
vcpu->arch.pfault_token = KVM_S390_PFAULT_TOKEN_INVALID;
|
||||
@ -3956,14 +3961,12 @@ retry:
|
||||
return 0;
|
||||
}
|
||||
|
||||
void kvm_s390_set_tod_clock(struct kvm *kvm,
|
||||
const struct kvm_s390_vm_tod_clock *gtod)
|
||||
static void __kvm_s390_set_tod_clock(struct kvm *kvm, const struct kvm_s390_vm_tod_clock *gtod)
|
||||
{
|
||||
struct kvm_vcpu *vcpu;
|
||||
union tod_clock clk;
|
||||
unsigned long i;
|
||||
|
||||
mutex_lock(&kvm->lock);
|
||||
preempt_disable();
|
||||
|
||||
store_tod_clock_ext(&clk);
|
||||
@ -3984,9 +3987,24 @@ void kvm_s390_set_tod_clock(struct kvm *kvm,
|
||||
|
||||
kvm_s390_vcpu_unblock_all(kvm);
|
||||
preempt_enable();
|
||||
}
|
||||
|
||||
void kvm_s390_set_tod_clock(struct kvm *kvm, const struct kvm_s390_vm_tod_clock *gtod)
|
||||
{
|
||||
mutex_lock(&kvm->lock);
|
||||
__kvm_s390_set_tod_clock(kvm, gtod);
|
||||
mutex_unlock(&kvm->lock);
|
||||
}
|
||||
|
||||
int kvm_s390_try_set_tod_clock(struct kvm *kvm, const struct kvm_s390_vm_tod_clock *gtod)
|
||||
{
|
||||
if (!mutex_trylock(&kvm->lock))
|
||||
return 0;
|
||||
__kvm_s390_set_tod_clock(kvm, gtod);
|
||||
mutex_unlock(&kvm->lock);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* kvm_arch_fault_in_page - fault-in guest page if necessary
|
||||
* @vcpu: The corresponding virtual cpu
|
||||
|
||||
@ -231,6 +231,15 @@ static inline unsigned long kvm_s390_get_gfn_end(struct kvm_memslots *slots)
|
||||
return ms->base_gfn + ms->npages;
|
||||
}
|
||||
|
||||
static inline u32 kvm_s390_get_gisa_desc(struct kvm *kvm)
|
||||
{
|
||||
u32 gd = (u32)(u64)kvm->arch.gisa_int.origin;
|
||||
|
||||
if (gd && sclp.has_gisaf)
|
||||
gd |= GISA_FORMAT1;
|
||||
return gd;
|
||||
}
|
||||
|
||||
/* implemented in pv.c */
|
||||
int kvm_s390_pv_destroy_cpu(struct kvm_vcpu *vcpu, u16 *rc, u16 *rrc);
|
||||
int kvm_s390_pv_create_cpu(struct kvm_vcpu *vcpu, u16 *rc, u16 *rrc);
|
||||
@ -349,8 +358,8 @@ int kvm_s390_handle_sigp(struct kvm_vcpu *vcpu);
|
||||
int kvm_s390_handle_sigp_pei(struct kvm_vcpu *vcpu);
|
||||
|
||||
/* implemented in kvm-s390.c */
|
||||
void kvm_s390_set_tod_clock(struct kvm *kvm,
|
||||
const struct kvm_s390_vm_tod_clock *gtod);
|
||||
void kvm_s390_set_tod_clock(struct kvm *kvm, const struct kvm_s390_vm_tod_clock *gtod);
|
||||
int kvm_s390_try_set_tod_clock(struct kvm *kvm, const struct kvm_s390_vm_tod_clock *gtod);
|
||||
long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable);
|
||||
int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long addr);
|
||||
int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr);
|
||||
@ -450,6 +459,8 @@ int kvm_s390_get_irq_state(struct kvm_vcpu *vcpu,
|
||||
void kvm_s390_gisa_init(struct kvm *kvm);
|
||||
void kvm_s390_gisa_clear(struct kvm *kvm);
|
||||
void kvm_s390_gisa_destroy(struct kvm *kvm);
|
||||
void kvm_s390_gisa_disable(struct kvm *kvm);
|
||||
void kvm_s390_gisa_enable(struct kvm *kvm);
|
||||
int kvm_s390_gib_init(u8 nisc);
|
||||
void kvm_s390_gib_destroy(void);
|
||||
|
||||
|
||||
@ -102,7 +102,20 @@ static int handle_set_clock(struct kvm_vcpu *vcpu)
|
||||
return kvm_s390_inject_prog_cond(vcpu, rc);
|
||||
|
||||
VCPU_EVENT(vcpu, 3, "SCK: setting guest TOD to 0x%llx", gtod.tod);
|
||||
kvm_s390_set_tod_clock(vcpu->kvm, >od);
|
||||
/*
|
||||
* To set the TOD clock the kvm lock must be taken, but the vcpu lock
|
||||
* is already held in handle_set_clock. The usual lock order is the
|
||||
* opposite. As SCK is deprecated and should not be used in several
|
||||
* cases, for example when the multiple epoch facility or TOD clock
|
||||
* steering facility is installed (see Principles of Operation), a
|
||||
* slow path can be used. If the lock can not be taken via try_lock,
|
||||
* the instruction will be retried via -EAGAIN at a later point in
|
||||
* time.
|
||||
*/
|
||||
if (!kvm_s390_try_set_tod_clock(vcpu->kvm, >od)) {
|
||||
kvm_s390_retry_instr(vcpu);
|
||||
return -EAGAIN;
|
||||
}
|
||||
|
||||
kvm_s390_set_psw_cc(vcpu, 0);
|
||||
return 0;
|
||||
|
||||
@ -13,169 +13,668 @@
|
||||
#include "test_util.h"
|
||||
#include "kvm_util.h"
|
||||
|
||||
enum mop_target {
|
||||
LOGICAL,
|
||||
SIDA,
|
||||
ABSOLUTE,
|
||||
INVALID,
|
||||
};
|
||||
|
||||
enum mop_access_mode {
|
||||
READ,
|
||||
WRITE,
|
||||
};
|
||||
|
||||
struct mop_desc {
|
||||
uintptr_t gaddr;
|
||||
uintptr_t gaddr_v;
|
||||
uint64_t set_flags;
|
||||
unsigned int f_check : 1;
|
||||
unsigned int f_inject : 1;
|
||||
unsigned int f_key : 1;
|
||||
unsigned int _gaddr_v : 1;
|
||||
unsigned int _set_flags : 1;
|
||||
unsigned int _sida_offset : 1;
|
||||
unsigned int _ar : 1;
|
||||
uint32_t size;
|
||||
enum mop_target target;
|
||||
enum mop_access_mode mode;
|
||||
void *buf;
|
||||
uint32_t sida_offset;
|
||||
uint8_t ar;
|
||||
uint8_t key;
|
||||
};
|
||||
|
||||
static struct kvm_s390_mem_op ksmo_from_desc(struct mop_desc desc)
|
||||
{
|
||||
struct kvm_s390_mem_op ksmo = {
|
||||
.gaddr = (uintptr_t)desc.gaddr,
|
||||
.size = desc.size,
|
||||
.buf = ((uintptr_t)desc.buf),
|
||||
.reserved = "ignored_ignored_ignored_ignored"
|
||||
};
|
||||
|
||||
switch (desc.target) {
|
||||
case LOGICAL:
|
||||
if (desc.mode == READ)
|
||||
ksmo.op = KVM_S390_MEMOP_LOGICAL_READ;
|
||||
if (desc.mode == WRITE)
|
||||
ksmo.op = KVM_S390_MEMOP_LOGICAL_WRITE;
|
||||
break;
|
||||
case SIDA:
|
||||
if (desc.mode == READ)
|
||||
ksmo.op = KVM_S390_MEMOP_SIDA_READ;
|
||||
if (desc.mode == WRITE)
|
||||
ksmo.op = KVM_S390_MEMOP_SIDA_WRITE;
|
||||
break;
|
||||
case ABSOLUTE:
|
||||
if (desc.mode == READ)
|
||||
ksmo.op = KVM_S390_MEMOP_ABSOLUTE_READ;
|
||||
if (desc.mode == WRITE)
|
||||
ksmo.op = KVM_S390_MEMOP_ABSOLUTE_WRITE;
|
||||
break;
|
||||
case INVALID:
|
||||
ksmo.op = -1;
|
||||
}
|
||||
if (desc.f_check)
|
||||
ksmo.flags |= KVM_S390_MEMOP_F_CHECK_ONLY;
|
||||
if (desc.f_inject)
|
||||
ksmo.flags |= KVM_S390_MEMOP_F_INJECT_EXCEPTION;
|
||||
if (desc._set_flags)
|
||||
ksmo.flags = desc.set_flags;
|
||||
if (desc.f_key) {
|
||||
ksmo.flags |= KVM_S390_MEMOP_F_SKEY_PROTECTION;
|
||||
ksmo.key = desc.key;
|
||||
}
|
||||
if (desc._ar)
|
||||
ksmo.ar = desc.ar;
|
||||
else
|
||||
ksmo.ar = 0;
|
||||
if (desc._sida_offset)
|
||||
ksmo.sida_offset = desc.sida_offset;
|
||||
|
||||
return ksmo;
|
||||
}
|
||||
|
||||
/* vcpu dummy id signifying that vm instead of vcpu ioctl is to occur */
|
||||
const uint32_t VM_VCPU_ID = (uint32_t)-1;
|
||||
|
||||
struct test_vcpu {
|
||||
struct kvm_vm *vm;
|
||||
uint32_t id;
|
||||
};
|
||||
|
||||
#define PRINT_MEMOP false
|
||||
static void print_memop(uint32_t vcpu_id, const struct kvm_s390_mem_op *ksmo)
|
||||
{
|
||||
if (!PRINT_MEMOP)
|
||||
return;
|
||||
|
||||
if (vcpu_id == VM_VCPU_ID)
|
||||
printf("vm memop(");
|
||||
else
|
||||
printf("vcpu memop(");
|
||||
switch (ksmo->op) {
|
||||
case KVM_S390_MEMOP_LOGICAL_READ:
|
||||
printf("LOGICAL, READ, ");
|
||||
break;
|
||||
case KVM_S390_MEMOP_LOGICAL_WRITE:
|
||||
printf("LOGICAL, WRITE, ");
|
||||
break;
|
||||
case KVM_S390_MEMOP_SIDA_READ:
|
||||
printf("SIDA, READ, ");
|
||||
break;
|
||||
case KVM_S390_MEMOP_SIDA_WRITE:
|
||||
printf("SIDA, WRITE, ");
|
||||
break;
|
||||
case KVM_S390_MEMOP_ABSOLUTE_READ:
|
||||
printf("ABSOLUTE, READ, ");
|
||||
break;
|
||||
case KVM_S390_MEMOP_ABSOLUTE_WRITE:
|
||||
printf("ABSOLUTE, WRITE, ");
|
||||
break;
|
||||
}
|
||||
printf("gaddr=%llu, size=%u, buf=%llu, ar=%u, key=%u",
|
||||
ksmo->gaddr, ksmo->size, ksmo->buf, ksmo->ar, ksmo->key);
|
||||
if (ksmo->flags & KVM_S390_MEMOP_F_CHECK_ONLY)
|
||||
printf(", CHECK_ONLY");
|
||||
if (ksmo->flags & KVM_S390_MEMOP_F_INJECT_EXCEPTION)
|
||||
printf(", INJECT_EXCEPTION");
|
||||
if (ksmo->flags & KVM_S390_MEMOP_F_SKEY_PROTECTION)
|
||||
printf(", SKEY_PROTECTION");
|
||||
puts(")");
|
||||
}
|
||||
|
||||
static void memop_ioctl(struct test_vcpu vcpu, struct kvm_s390_mem_op *ksmo)
|
||||
{
|
||||
if (vcpu.id == VM_VCPU_ID)
|
||||
vm_ioctl(vcpu.vm, KVM_S390_MEM_OP, ksmo);
|
||||
else
|
||||
vcpu_ioctl(vcpu.vm, vcpu.id, KVM_S390_MEM_OP, ksmo);
|
||||
}
|
||||
|
||||
static int err_memop_ioctl(struct test_vcpu vcpu, struct kvm_s390_mem_op *ksmo)
|
||||
{
|
||||
if (vcpu.id == VM_VCPU_ID)
|
||||
return _vm_ioctl(vcpu.vm, KVM_S390_MEM_OP, ksmo);
|
||||
else
|
||||
return _vcpu_ioctl(vcpu.vm, vcpu.id, KVM_S390_MEM_OP, ksmo);
|
||||
}
|
||||
|
||||
#define MEMOP(err, vcpu_p, mop_target_p, access_mode_p, buf_p, size_p, ...) \
|
||||
({ \
|
||||
struct test_vcpu __vcpu = (vcpu_p); \
|
||||
struct mop_desc __desc = { \
|
||||
.target = (mop_target_p), \
|
||||
.mode = (access_mode_p), \
|
||||
.buf = (buf_p), \
|
||||
.size = (size_p), \
|
||||
__VA_ARGS__ \
|
||||
}; \
|
||||
struct kvm_s390_mem_op __ksmo; \
|
||||
\
|
||||
if (__desc._gaddr_v) { \
|
||||
if (__desc.target == ABSOLUTE) \
|
||||
__desc.gaddr = addr_gva2gpa(__vcpu.vm, __desc.gaddr_v); \
|
||||
else \
|
||||
__desc.gaddr = __desc.gaddr_v; \
|
||||
} \
|
||||
__ksmo = ksmo_from_desc(__desc); \
|
||||
print_memop(__vcpu.id, &__ksmo); \
|
||||
err##memop_ioctl(__vcpu, &__ksmo); \
|
||||
})
|
||||
|
||||
#define MOP(...) MEMOP(, __VA_ARGS__)
|
||||
#define ERR_MOP(...) MEMOP(err_, __VA_ARGS__)
|
||||
|
||||
#define GADDR(a) .gaddr = ((uintptr_t)a)
|
||||
#define GADDR_V(v) ._gaddr_v = 1, .gaddr_v = ((uintptr_t)v)
|
||||
#define CHECK_ONLY .f_check = 1
|
||||
#define SET_FLAGS(f) ._set_flags = 1, .set_flags = (f)
|
||||
#define SIDA_OFFSET(o) ._sida_offset = 1, .sida_offset = (o)
|
||||
#define AR(a) ._ar = 1, .ar = (a)
|
||||
#define KEY(a) .f_key = 1, .key = (a)
|
||||
|
||||
#define CHECK_N_DO(f, ...) ({ f(__VA_ARGS__, CHECK_ONLY); f(__VA_ARGS__); })
|
||||
|
||||
#define VCPU_ID 1
|
||||
#define PAGE_SHIFT 12
|
||||
#define PAGE_SIZE (1ULL << PAGE_SHIFT)
|
||||
#define PAGE_MASK (~(PAGE_SIZE - 1))
|
||||
#define CR0_FETCH_PROTECTION_OVERRIDE (1UL << (63 - 38))
|
||||
#define CR0_STORAGE_PROTECTION_OVERRIDE (1UL << (63 - 39))
|
||||
|
||||
static uint8_t mem1[65536];
|
||||
static uint8_t mem2[65536];
|
||||
|
||||
static void guest_code(void)
|
||||
struct test_default {
|
||||
struct kvm_vm *kvm_vm;
|
||||
struct test_vcpu vm;
|
||||
struct test_vcpu vcpu;
|
||||
struct kvm_run *run;
|
||||
int size;
|
||||
};
|
||||
|
||||
static struct test_default test_default_init(void *guest_code)
|
||||
{
|
||||
struct test_default t;
|
||||
|
||||
t.size = min((size_t)kvm_check_cap(KVM_CAP_S390_MEM_OP), sizeof(mem1));
|
||||
t.kvm_vm = vm_create_default(VCPU_ID, 0, guest_code);
|
||||
t.vm = (struct test_vcpu) { t.kvm_vm, VM_VCPU_ID };
|
||||
t.vcpu = (struct test_vcpu) { t.kvm_vm, VCPU_ID };
|
||||
t.run = vcpu_state(t.kvm_vm, VCPU_ID);
|
||||
return t;
|
||||
}
|
||||
|
||||
enum stage {
|
||||
/* Synced state set by host, e.g. DAT */
|
||||
STAGE_INITED,
|
||||
/* Guest did nothing */
|
||||
STAGE_IDLED,
|
||||
/* Guest set storage keys (specifics up to test case) */
|
||||
STAGE_SKEYS_SET,
|
||||
/* Guest copied memory (locations up to test case) */
|
||||
STAGE_COPIED,
|
||||
};
|
||||
|
||||
#define HOST_SYNC(vcpu_p, stage) \
|
||||
({ \
|
||||
struct test_vcpu __vcpu = (vcpu_p); \
|
||||
struct ucall uc; \
|
||||
int __stage = (stage); \
|
||||
\
|
||||
vcpu_run(__vcpu.vm, __vcpu.id); \
|
||||
get_ucall(__vcpu.vm, __vcpu.id, &uc); \
|
||||
ASSERT_EQ(uc.cmd, UCALL_SYNC); \
|
||||
ASSERT_EQ(uc.args[1], __stage); \
|
||||
}) \
|
||||
|
||||
static void prepare_mem12(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (;;) {
|
||||
for (i = 0; i < sizeof(mem2); i++)
|
||||
mem2[i] = mem1[i];
|
||||
GUEST_SYNC(0);
|
||||
for (i = 0; i < sizeof(mem1); i++)
|
||||
mem1[i] = rand();
|
||||
memset(mem2, 0xaa, sizeof(mem2));
|
||||
}
|
||||
|
||||
#define ASSERT_MEM_EQ(p1, p2, size) \
|
||||
TEST_ASSERT(!memcmp(p1, p2, size), "Memory contents do not match!")
|
||||
|
||||
#define DEFAULT_WRITE_READ(copy_cpu, mop_cpu, mop_target_p, size, ...) \
|
||||
({ \
|
||||
struct test_vcpu __copy_cpu = (copy_cpu), __mop_cpu = (mop_cpu); \
|
||||
enum mop_target __target = (mop_target_p); \
|
||||
uint32_t __size = (size); \
|
||||
\
|
||||
prepare_mem12(); \
|
||||
CHECK_N_DO(MOP, __mop_cpu, __target, WRITE, mem1, __size, \
|
||||
GADDR_V(mem1), ##__VA_ARGS__); \
|
||||
HOST_SYNC(__copy_cpu, STAGE_COPIED); \
|
||||
CHECK_N_DO(MOP, __mop_cpu, __target, READ, mem2, __size, \
|
||||
GADDR_V(mem2), ##__VA_ARGS__); \
|
||||
ASSERT_MEM_EQ(mem1, mem2, __size); \
|
||||
})
|
||||
|
||||
#define DEFAULT_READ(copy_cpu, mop_cpu, mop_target_p, size, ...) \
|
||||
({ \
|
||||
struct test_vcpu __copy_cpu = (copy_cpu), __mop_cpu = (mop_cpu); \
|
||||
enum mop_target __target = (mop_target_p); \
|
||||
uint32_t __size = (size); \
|
||||
\
|
||||
prepare_mem12(); \
|
||||
CHECK_N_DO(MOP, __mop_cpu, __target, WRITE, mem1, __size, \
|
||||
GADDR_V(mem1)); \
|
||||
HOST_SYNC(__copy_cpu, STAGE_COPIED); \
|
||||
CHECK_N_DO(MOP, __mop_cpu, __target, READ, mem2, __size, ##__VA_ARGS__);\
|
||||
ASSERT_MEM_EQ(mem1, mem2, __size); \
|
||||
})
|
||||
|
||||
static void guest_copy(void)
|
||||
{
|
||||
GUEST_SYNC(STAGE_INITED);
|
||||
memcpy(&mem2, &mem1, sizeof(mem2));
|
||||
GUEST_SYNC(STAGE_COPIED);
|
||||
}
|
||||
|
||||
static void test_copy(void)
|
||||
{
|
||||
struct test_default t = test_default_init(guest_copy);
|
||||
|
||||
HOST_SYNC(t.vcpu, STAGE_INITED);
|
||||
|
||||
DEFAULT_WRITE_READ(t.vcpu, t.vcpu, LOGICAL, t.size);
|
||||
|
||||
kvm_vm_free(t.kvm_vm);
|
||||
}
|
||||
|
||||
static void set_storage_key_range(void *addr, size_t len, uint8_t key)
|
||||
{
|
||||
uintptr_t _addr, abs, i;
|
||||
int not_mapped = 0;
|
||||
|
||||
_addr = (uintptr_t)addr;
|
||||
for (i = _addr & PAGE_MASK; i < _addr + len; i += PAGE_SIZE) {
|
||||
abs = i;
|
||||
asm volatile (
|
||||
"lra %[abs], 0(0,%[abs])\n"
|
||||
" jz 0f\n"
|
||||
" llill %[not_mapped],1\n"
|
||||
" j 1f\n"
|
||||
"0: sske %[key], %[abs]\n"
|
||||
"1:"
|
||||
: [abs] "+&a" (abs), [not_mapped] "+r" (not_mapped)
|
||||
: [key] "r" (key)
|
||||
: "cc"
|
||||
);
|
||||
GUEST_ASSERT_EQ(not_mapped, 0);
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
static void guest_copy_key(void)
|
||||
{
|
||||
struct kvm_vm *vm;
|
||||
struct kvm_run *run;
|
||||
struct kvm_s390_mem_op ksmo;
|
||||
int rv, i, maxsize;
|
||||
set_storage_key_range(mem1, sizeof(mem1), 0x90);
|
||||
set_storage_key_range(mem2, sizeof(mem2), 0x90);
|
||||
GUEST_SYNC(STAGE_SKEYS_SET);
|
||||
|
||||
setbuf(stdout, NULL); /* Tell stdout not to buffer its content */
|
||||
|
||||
maxsize = kvm_check_cap(KVM_CAP_S390_MEM_OP);
|
||||
if (!maxsize) {
|
||||
print_skip("CAP_S390_MEM_OP not supported");
|
||||
exit(KSFT_SKIP);
|
||||
for (;;) {
|
||||
memcpy(&mem2, &mem1, sizeof(mem2));
|
||||
GUEST_SYNC(STAGE_COPIED);
|
||||
}
|
||||
if (maxsize > sizeof(mem1))
|
||||
maxsize = sizeof(mem1);
|
||||
}
|
||||
|
||||
/* Create VM */
|
||||
vm = vm_create_default(VCPU_ID, 0, guest_code);
|
||||
run = vcpu_state(vm, VCPU_ID);
|
||||
static void test_copy_key(void)
|
||||
{
|
||||
struct test_default t = test_default_init(guest_copy_key);
|
||||
|
||||
for (i = 0; i < sizeof(mem1); i++)
|
||||
mem1[i] = i * i + i;
|
||||
HOST_SYNC(t.vcpu, STAGE_SKEYS_SET);
|
||||
|
||||
/* Set the first array */
|
||||
ksmo.gaddr = addr_gva2gpa(vm, (uintptr_t)mem1);
|
||||
ksmo.flags = 0;
|
||||
ksmo.size = maxsize;
|
||||
ksmo.op = KVM_S390_MEMOP_LOGICAL_WRITE;
|
||||
ksmo.buf = (uintptr_t)mem1;
|
||||
ksmo.ar = 0;
|
||||
vcpu_ioctl(vm, VCPU_ID, KVM_S390_MEM_OP, &ksmo);
|
||||
/* vm, no key */
|
||||
DEFAULT_WRITE_READ(t.vcpu, t.vm, ABSOLUTE, t.size);
|
||||
|
||||
/* Let the guest code copy the first array to the second */
|
||||
vcpu_run(vm, VCPU_ID);
|
||||
TEST_ASSERT(run->exit_reason == KVM_EXIT_S390_SIEIC,
|
||||
"Unexpected exit reason: %u (%s)\n",
|
||||
run->exit_reason,
|
||||
exit_reason_str(run->exit_reason));
|
||||
/* vm/vcpu, machting key or key 0 */
|
||||
DEFAULT_WRITE_READ(t.vcpu, t.vcpu, LOGICAL, t.size, KEY(0));
|
||||
DEFAULT_WRITE_READ(t.vcpu, t.vcpu, LOGICAL, t.size, KEY(9));
|
||||
DEFAULT_WRITE_READ(t.vcpu, t.vm, ABSOLUTE, t.size, KEY(0));
|
||||
DEFAULT_WRITE_READ(t.vcpu, t.vm, ABSOLUTE, t.size, KEY(9));
|
||||
/*
|
||||
* There used to be different code paths for key handling depending on
|
||||
* if the region crossed a page boundary.
|
||||
* There currently are not, but the more tests the merrier.
|
||||
*/
|
||||
DEFAULT_WRITE_READ(t.vcpu, t.vcpu, LOGICAL, 1, KEY(0));
|
||||
DEFAULT_WRITE_READ(t.vcpu, t.vcpu, LOGICAL, 1, KEY(9));
|
||||
DEFAULT_WRITE_READ(t.vcpu, t.vm, ABSOLUTE, 1, KEY(0));
|
||||
DEFAULT_WRITE_READ(t.vcpu, t.vm, ABSOLUTE, 1, KEY(9));
|
||||
|
||||
memset(mem2, 0xaa, sizeof(mem2));
|
||||
/* vm/vcpu, mismatching keys on read, but no fetch protection */
|
||||
DEFAULT_READ(t.vcpu, t.vcpu, LOGICAL, t.size, GADDR_V(mem2), KEY(2));
|
||||
DEFAULT_READ(t.vcpu, t.vm, ABSOLUTE, t.size, GADDR_V(mem1), KEY(2));
|
||||
|
||||
/* Get the second array */
|
||||
ksmo.gaddr = (uintptr_t)mem2;
|
||||
ksmo.flags = 0;
|
||||
ksmo.size = maxsize;
|
||||
ksmo.op = KVM_S390_MEMOP_LOGICAL_READ;
|
||||
ksmo.buf = (uintptr_t)mem2;
|
||||
ksmo.ar = 0;
|
||||
vcpu_ioctl(vm, VCPU_ID, KVM_S390_MEM_OP, &ksmo);
|
||||
kvm_vm_free(t.kvm_vm);
|
||||
}
|
||||
|
||||
TEST_ASSERT(!memcmp(mem1, mem2, maxsize),
|
||||
"Memory contents do not match!");
|
||||
static void guest_copy_key_fetch_prot(void)
|
||||
{
|
||||
/*
|
||||
* For some reason combining the first sync with override enablement
|
||||
* results in an exception when calling HOST_SYNC.
|
||||
*/
|
||||
GUEST_SYNC(STAGE_INITED);
|
||||
/* Storage protection override applies to both store and fetch. */
|
||||
set_storage_key_range(mem1, sizeof(mem1), 0x98);
|
||||
set_storage_key_range(mem2, sizeof(mem2), 0x98);
|
||||
GUEST_SYNC(STAGE_SKEYS_SET);
|
||||
|
||||
/* Check error conditions - first bad size: */
|
||||
ksmo.gaddr = (uintptr_t)mem1;
|
||||
ksmo.flags = 0;
|
||||
ksmo.size = -1;
|
||||
ksmo.op = KVM_S390_MEMOP_LOGICAL_WRITE;
|
||||
ksmo.buf = (uintptr_t)mem1;
|
||||
ksmo.ar = 0;
|
||||
rv = _vcpu_ioctl(vm, VCPU_ID, KVM_S390_MEM_OP, &ksmo);
|
||||
for (;;) {
|
||||
memcpy(&mem2, &mem1, sizeof(mem2));
|
||||
GUEST_SYNC(STAGE_COPIED);
|
||||
}
|
||||
}
|
||||
|
||||
static void test_copy_key_storage_prot_override(void)
|
||||
{
|
||||
struct test_default t = test_default_init(guest_copy_key_fetch_prot);
|
||||
|
||||
HOST_SYNC(t.vcpu, STAGE_INITED);
|
||||
t.run->s.regs.crs[0] |= CR0_STORAGE_PROTECTION_OVERRIDE;
|
||||
t.run->kvm_dirty_regs = KVM_SYNC_CRS;
|
||||
HOST_SYNC(t.vcpu, STAGE_SKEYS_SET);
|
||||
|
||||
/* vcpu, mismatching keys, storage protection override in effect */
|
||||
DEFAULT_WRITE_READ(t.vcpu, t.vcpu, LOGICAL, t.size, KEY(2));
|
||||
|
||||
kvm_vm_free(t.kvm_vm);
|
||||
}
|
||||
|
||||
static void test_copy_key_fetch_prot(void)
|
||||
{
|
||||
struct test_default t = test_default_init(guest_copy_key_fetch_prot);
|
||||
|
||||
HOST_SYNC(t.vcpu, STAGE_INITED);
|
||||
HOST_SYNC(t.vcpu, STAGE_SKEYS_SET);
|
||||
|
||||
/* vm/vcpu, matching key, fetch protection in effect */
|
||||
DEFAULT_READ(t.vcpu, t.vcpu, LOGICAL, t.size, GADDR_V(mem2), KEY(9));
|
||||
DEFAULT_READ(t.vcpu, t.vm, ABSOLUTE, t.size, GADDR_V(mem2), KEY(9));
|
||||
|
||||
kvm_vm_free(t.kvm_vm);
|
||||
}
|
||||
|
||||
#define ERR_PROT_MOP(...) \
|
||||
({ \
|
||||
int rv; \
|
||||
\
|
||||
rv = ERR_MOP(__VA_ARGS__); \
|
||||
TEST_ASSERT(rv == 4, "Should result in protection exception"); \
|
||||
})
|
||||
|
||||
static void test_errors_key(void)
|
||||
{
|
||||
struct test_default t = test_default_init(guest_copy_key_fetch_prot);
|
||||
|
||||
HOST_SYNC(t.vcpu, STAGE_INITED);
|
||||
HOST_SYNC(t.vcpu, STAGE_SKEYS_SET);
|
||||
|
||||
/* vm/vcpu, mismatching keys, fetch protection in effect */
|
||||
CHECK_N_DO(ERR_PROT_MOP, t.vcpu, LOGICAL, WRITE, mem1, t.size, GADDR_V(mem1), KEY(2));
|
||||
CHECK_N_DO(ERR_PROT_MOP, t.vcpu, LOGICAL, READ, mem2, t.size, GADDR_V(mem2), KEY(2));
|
||||
CHECK_N_DO(ERR_PROT_MOP, t.vm, ABSOLUTE, WRITE, mem1, t.size, GADDR_V(mem1), KEY(2));
|
||||
CHECK_N_DO(ERR_PROT_MOP, t.vm, ABSOLUTE, READ, mem2, t.size, GADDR_V(mem2), KEY(2));
|
||||
|
||||
kvm_vm_free(t.kvm_vm);
|
||||
}
|
||||
|
||||
static void test_errors_key_storage_prot_override(void)
|
||||
{
|
||||
struct test_default t = test_default_init(guest_copy_key_fetch_prot);
|
||||
|
||||
HOST_SYNC(t.vcpu, STAGE_INITED);
|
||||
t.run->s.regs.crs[0] |= CR0_STORAGE_PROTECTION_OVERRIDE;
|
||||
t.run->kvm_dirty_regs = KVM_SYNC_CRS;
|
||||
HOST_SYNC(t.vcpu, STAGE_SKEYS_SET);
|
||||
|
||||
/* vm, mismatching keys, storage protection override not applicable to vm */
|
||||
CHECK_N_DO(ERR_PROT_MOP, t.vm, ABSOLUTE, WRITE, mem1, t.size, GADDR_V(mem1), KEY(2));
|
||||
CHECK_N_DO(ERR_PROT_MOP, t.vm, ABSOLUTE, READ, mem2, t.size, GADDR_V(mem2), KEY(2));
|
||||
|
||||
kvm_vm_free(t.kvm_vm);
|
||||
}
|
||||
|
||||
const uint64_t last_page_addr = -PAGE_SIZE;
|
||||
|
||||
static void guest_copy_key_fetch_prot_override(void)
|
||||
{
|
||||
int i;
|
||||
char *page_0 = 0;
|
||||
|
||||
GUEST_SYNC(STAGE_INITED);
|
||||
set_storage_key_range(0, PAGE_SIZE, 0x18);
|
||||
set_storage_key_range((void *)last_page_addr, PAGE_SIZE, 0x0);
|
||||
asm volatile ("sske %[key],%[addr]\n" :: [addr] "r"(0), [key] "r"(0x18) : "cc");
|
||||
GUEST_SYNC(STAGE_SKEYS_SET);
|
||||
|
||||
for (;;) {
|
||||
for (i = 0; i < PAGE_SIZE; i++)
|
||||
page_0[i] = mem1[i];
|
||||
GUEST_SYNC(STAGE_COPIED);
|
||||
}
|
||||
}
|
||||
|
||||
static void test_copy_key_fetch_prot_override(void)
|
||||
{
|
||||
struct test_default t = test_default_init(guest_copy_key_fetch_prot_override);
|
||||
vm_vaddr_t guest_0_page, guest_last_page;
|
||||
|
||||
guest_0_page = vm_vaddr_alloc(t.kvm_vm, PAGE_SIZE, 0);
|
||||
guest_last_page = vm_vaddr_alloc(t.kvm_vm, PAGE_SIZE, last_page_addr);
|
||||
if (guest_0_page != 0 || guest_last_page != last_page_addr) {
|
||||
print_skip("did not allocate guest pages at required positions");
|
||||
goto out;
|
||||
}
|
||||
|
||||
HOST_SYNC(t.vcpu, STAGE_INITED);
|
||||
t.run->s.regs.crs[0] |= CR0_FETCH_PROTECTION_OVERRIDE;
|
||||
t.run->kvm_dirty_regs = KVM_SYNC_CRS;
|
||||
HOST_SYNC(t.vcpu, STAGE_SKEYS_SET);
|
||||
|
||||
/* vcpu, mismatching keys on fetch, fetch protection override applies */
|
||||
prepare_mem12();
|
||||
MOP(t.vcpu, LOGICAL, WRITE, mem1, PAGE_SIZE, GADDR_V(mem1));
|
||||
HOST_SYNC(t.vcpu, STAGE_COPIED);
|
||||
CHECK_N_DO(MOP, t.vcpu, LOGICAL, READ, mem2, 2048, GADDR_V(guest_0_page), KEY(2));
|
||||
ASSERT_MEM_EQ(mem1, mem2, 2048);
|
||||
|
||||
/*
|
||||
* vcpu, mismatching keys on fetch, fetch protection override applies,
|
||||
* wraparound
|
||||
*/
|
||||
prepare_mem12();
|
||||
MOP(t.vcpu, LOGICAL, WRITE, mem1, 2 * PAGE_SIZE, GADDR_V(guest_last_page));
|
||||
HOST_SYNC(t.vcpu, STAGE_COPIED);
|
||||
CHECK_N_DO(MOP, t.vcpu, LOGICAL, READ, mem2, PAGE_SIZE + 2048,
|
||||
GADDR_V(guest_last_page), KEY(2));
|
||||
ASSERT_MEM_EQ(mem1, mem2, 2048);
|
||||
|
||||
out:
|
||||
kvm_vm_free(t.kvm_vm);
|
||||
}
|
||||
|
||||
static void test_errors_key_fetch_prot_override_not_enabled(void)
|
||||
{
|
||||
struct test_default t = test_default_init(guest_copy_key_fetch_prot_override);
|
||||
vm_vaddr_t guest_0_page, guest_last_page;
|
||||
|
||||
guest_0_page = vm_vaddr_alloc(t.kvm_vm, PAGE_SIZE, 0);
|
||||
guest_last_page = vm_vaddr_alloc(t.kvm_vm, PAGE_SIZE, last_page_addr);
|
||||
if (guest_0_page != 0 || guest_last_page != last_page_addr) {
|
||||
print_skip("did not allocate guest pages at required positions");
|
||||
goto out;
|
||||
}
|
||||
HOST_SYNC(t.vcpu, STAGE_INITED);
|
||||
HOST_SYNC(t.vcpu, STAGE_SKEYS_SET);
|
||||
|
||||
/* vcpu, mismatching keys on fetch, fetch protection override not enabled */
|
||||
CHECK_N_DO(ERR_PROT_MOP, t.vcpu, LOGICAL, READ, mem2, 2048, GADDR_V(0), KEY(2));
|
||||
|
||||
out:
|
||||
kvm_vm_free(t.kvm_vm);
|
||||
}
|
||||
|
||||
static void test_errors_key_fetch_prot_override_enabled(void)
|
||||
{
|
||||
struct test_default t = test_default_init(guest_copy_key_fetch_prot_override);
|
||||
vm_vaddr_t guest_0_page, guest_last_page;
|
||||
|
||||
guest_0_page = vm_vaddr_alloc(t.kvm_vm, PAGE_SIZE, 0);
|
||||
guest_last_page = vm_vaddr_alloc(t.kvm_vm, PAGE_SIZE, last_page_addr);
|
||||
if (guest_0_page != 0 || guest_last_page != last_page_addr) {
|
||||
print_skip("did not allocate guest pages at required positions");
|
||||
goto out;
|
||||
}
|
||||
HOST_SYNC(t.vcpu, STAGE_INITED);
|
||||
t.run->s.regs.crs[0] |= CR0_FETCH_PROTECTION_OVERRIDE;
|
||||
t.run->kvm_dirty_regs = KVM_SYNC_CRS;
|
||||
HOST_SYNC(t.vcpu, STAGE_SKEYS_SET);
|
||||
|
||||
/*
|
||||
* vcpu, mismatching keys on fetch,
|
||||
* fetch protection override does not apply because memory range acceeded
|
||||
*/
|
||||
CHECK_N_DO(ERR_PROT_MOP, t.vcpu, LOGICAL, READ, mem2, 2048 + 1, GADDR_V(0), KEY(2));
|
||||
CHECK_N_DO(ERR_PROT_MOP, t.vcpu, LOGICAL, READ, mem2, PAGE_SIZE + 2048 + 1,
|
||||
GADDR_V(guest_last_page), KEY(2));
|
||||
/* vm, fetch protected override does not apply */
|
||||
CHECK_N_DO(ERR_PROT_MOP, t.vm, ABSOLUTE, READ, mem2, 2048, GADDR(0), KEY(2));
|
||||
CHECK_N_DO(ERR_PROT_MOP, t.vm, ABSOLUTE, READ, mem2, 2048, GADDR_V(guest_0_page), KEY(2));
|
||||
|
||||
out:
|
||||
kvm_vm_free(t.kvm_vm);
|
||||
}
|
||||
|
||||
static void guest_idle(void)
|
||||
{
|
||||
GUEST_SYNC(STAGE_INITED); /* for consistency's sake */
|
||||
for (;;)
|
||||
GUEST_SYNC(STAGE_IDLED);
|
||||
}
|
||||
|
||||
static void _test_errors_common(struct test_vcpu vcpu, enum mop_target target, int size)
|
||||
{
|
||||
int rv;
|
||||
|
||||
/* Bad size: */
|
||||
rv = ERR_MOP(vcpu, target, WRITE, mem1, -1, GADDR_V(mem1));
|
||||
TEST_ASSERT(rv == -1 && errno == E2BIG, "ioctl allows insane sizes");
|
||||
|
||||
/* Zero size: */
|
||||
ksmo.gaddr = (uintptr_t)mem1;
|
||||
ksmo.flags = 0;
|
||||
ksmo.size = 0;
|
||||
ksmo.op = KVM_S390_MEMOP_LOGICAL_WRITE;
|
||||
ksmo.buf = (uintptr_t)mem1;
|
||||
ksmo.ar = 0;
|
||||
rv = _vcpu_ioctl(vm, VCPU_ID, KVM_S390_MEM_OP, &ksmo);
|
||||
rv = ERR_MOP(vcpu, target, WRITE, mem1, 0, GADDR_V(mem1));
|
||||
TEST_ASSERT(rv == -1 && (errno == EINVAL || errno == ENOMEM),
|
||||
"ioctl allows 0 as size");
|
||||
|
||||
/* Bad flags: */
|
||||
ksmo.gaddr = (uintptr_t)mem1;
|
||||
ksmo.flags = -1;
|
||||
ksmo.size = maxsize;
|
||||
ksmo.op = KVM_S390_MEMOP_LOGICAL_WRITE;
|
||||
ksmo.buf = (uintptr_t)mem1;
|
||||
ksmo.ar = 0;
|
||||
rv = _vcpu_ioctl(vm, VCPU_ID, KVM_S390_MEM_OP, &ksmo);
|
||||
rv = ERR_MOP(vcpu, target, WRITE, mem1, size, GADDR_V(mem1), SET_FLAGS(-1));
|
||||
TEST_ASSERT(rv == -1 && errno == EINVAL, "ioctl allows all flags");
|
||||
|
||||
/* Bad operation: */
|
||||
ksmo.gaddr = (uintptr_t)mem1;
|
||||
ksmo.flags = 0;
|
||||
ksmo.size = maxsize;
|
||||
ksmo.op = -1;
|
||||
ksmo.buf = (uintptr_t)mem1;
|
||||
ksmo.ar = 0;
|
||||
rv = _vcpu_ioctl(vm, VCPU_ID, KVM_S390_MEM_OP, &ksmo);
|
||||
TEST_ASSERT(rv == -1 && errno == EINVAL, "ioctl allows bad operations");
|
||||
|
||||
/* Bad guest address: */
|
||||
ksmo.gaddr = ~0xfffUL;
|
||||
ksmo.flags = KVM_S390_MEMOP_F_CHECK_ONLY;
|
||||
ksmo.size = maxsize;
|
||||
ksmo.op = KVM_S390_MEMOP_LOGICAL_WRITE;
|
||||
ksmo.buf = (uintptr_t)mem1;
|
||||
ksmo.ar = 0;
|
||||
rv = _vcpu_ioctl(vm, VCPU_ID, KVM_S390_MEM_OP, &ksmo);
|
||||
rv = ERR_MOP(vcpu, target, WRITE, mem1, size, GADDR((void *)~0xfffUL), CHECK_ONLY);
|
||||
TEST_ASSERT(rv > 0, "ioctl does not report bad guest memory access");
|
||||
|
||||
/* Bad host address: */
|
||||
ksmo.gaddr = (uintptr_t)mem1;
|
||||
ksmo.flags = 0;
|
||||
ksmo.size = maxsize;
|
||||
ksmo.op = KVM_S390_MEMOP_LOGICAL_WRITE;
|
||||
ksmo.buf = 0;
|
||||
ksmo.ar = 0;
|
||||
rv = _vcpu_ioctl(vm, VCPU_ID, KVM_S390_MEM_OP, &ksmo);
|
||||
rv = ERR_MOP(vcpu, target, WRITE, 0, size, GADDR_V(mem1));
|
||||
TEST_ASSERT(rv == -1 && errno == EFAULT,
|
||||
"ioctl does not report bad host memory address");
|
||||
|
||||
/* Bad key: */
|
||||
rv = ERR_MOP(vcpu, target, WRITE, mem1, size, GADDR_V(mem1), KEY(17));
|
||||
TEST_ASSERT(rv == -1 && errno == EINVAL, "ioctl allows invalid key");
|
||||
}
|
||||
|
||||
static void test_errors(void)
|
||||
{
|
||||
struct test_default t = test_default_init(guest_idle);
|
||||
int rv;
|
||||
|
||||
HOST_SYNC(t.vcpu, STAGE_INITED);
|
||||
|
||||
_test_errors_common(t.vcpu, LOGICAL, t.size);
|
||||
_test_errors_common(t.vm, ABSOLUTE, t.size);
|
||||
|
||||
/* Bad operation: */
|
||||
rv = ERR_MOP(t.vcpu, INVALID, WRITE, mem1, t.size, GADDR_V(mem1));
|
||||
TEST_ASSERT(rv == -1 && errno == EINVAL, "ioctl allows bad operations");
|
||||
/* virtual addresses are not translated when passing INVALID */
|
||||
rv = ERR_MOP(t.vm, INVALID, WRITE, mem1, PAGE_SIZE, GADDR(0));
|
||||
TEST_ASSERT(rv == -1 && errno == EINVAL, "ioctl allows bad operations");
|
||||
|
||||
/* Bad access register: */
|
||||
run->psw_mask &= ~(3UL << (63 - 17));
|
||||
run->psw_mask |= 1UL << (63 - 17); /* Enable AR mode */
|
||||
vcpu_run(vm, VCPU_ID); /* To sync new state to SIE block */
|
||||
ksmo.gaddr = (uintptr_t)mem1;
|
||||
ksmo.flags = 0;
|
||||
ksmo.size = maxsize;
|
||||
ksmo.op = KVM_S390_MEMOP_LOGICAL_WRITE;
|
||||
ksmo.buf = (uintptr_t)mem1;
|
||||
ksmo.ar = 17;
|
||||
rv = _vcpu_ioctl(vm, VCPU_ID, KVM_S390_MEM_OP, &ksmo);
|
||||
t.run->psw_mask &= ~(3UL << (63 - 17));
|
||||
t.run->psw_mask |= 1UL << (63 - 17); /* Enable AR mode */
|
||||
HOST_SYNC(t.vcpu, STAGE_IDLED); /* To sync new state to SIE block */
|
||||
rv = ERR_MOP(t.vcpu, LOGICAL, WRITE, mem1, t.size, GADDR_V(mem1), AR(17));
|
||||
TEST_ASSERT(rv == -1 && errno == EINVAL, "ioctl allows ARs > 15");
|
||||
run->psw_mask &= ~(3UL << (63 - 17)); /* Disable AR mode */
|
||||
vcpu_run(vm, VCPU_ID); /* Run to sync new state */
|
||||
t.run->psw_mask &= ~(3UL << (63 - 17)); /* Disable AR mode */
|
||||
HOST_SYNC(t.vcpu, STAGE_IDLED); /* Run to sync new state */
|
||||
|
||||
/* Check that the SIDA calls are rejected for non-protected guests */
|
||||
ksmo.gaddr = 0;
|
||||
ksmo.flags = 0;
|
||||
ksmo.size = 8;
|
||||
ksmo.op = KVM_S390_MEMOP_SIDA_READ;
|
||||
ksmo.buf = (uintptr_t)mem1;
|
||||
ksmo.sida_offset = 0x1c0;
|
||||
rv = _vcpu_ioctl(vm, VCPU_ID, KVM_S390_MEM_OP, &ksmo);
|
||||
rv = ERR_MOP(t.vcpu, SIDA, READ, mem1, 8, GADDR(0), SIDA_OFFSET(0x1c0));
|
||||
TEST_ASSERT(rv == -1 && errno == EINVAL,
|
||||
"ioctl does not reject SIDA_READ in non-protected mode");
|
||||
ksmo.op = KVM_S390_MEMOP_SIDA_WRITE;
|
||||
rv = _vcpu_ioctl(vm, VCPU_ID, KVM_S390_MEM_OP, &ksmo);
|
||||
rv = ERR_MOP(t.vcpu, SIDA, WRITE, mem1, 8, GADDR(0), SIDA_OFFSET(0x1c0));
|
||||
TEST_ASSERT(rv == -1 && errno == EINVAL,
|
||||
"ioctl does not reject SIDA_WRITE in non-protected mode");
|
||||
|
||||
kvm_vm_free(vm);
|
||||
kvm_vm_free(t.kvm_vm);
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int memop_cap, extension_cap;
|
||||
|
||||
setbuf(stdout, NULL); /* Tell stdout not to buffer its content */
|
||||
|
||||
memop_cap = kvm_check_cap(KVM_CAP_S390_MEM_OP);
|
||||
extension_cap = kvm_check_cap(KVM_CAP_S390_MEM_OP_EXTENSION);
|
||||
if (!memop_cap) {
|
||||
print_skip("CAP_S390_MEM_OP not supported");
|
||||
exit(KSFT_SKIP);
|
||||
}
|
||||
|
||||
test_copy();
|
||||
if (extension_cap > 0) {
|
||||
test_copy_key();
|
||||
test_copy_key_storage_prot_override();
|
||||
test_copy_key_fetch_prot();
|
||||
test_copy_key_fetch_prot_override();
|
||||
test_errors_key();
|
||||
test_errors_key_storage_prot_override();
|
||||
test_errors_key_fetch_prot_override_not_enabled();
|
||||
test_errors_key_fetch_prot_override_enabled();
|
||||
} else {
|
||||
print_skip("storage key memop extension not supported");
|
||||
}
|
||||
test_errors();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user