priv.c 26.7 KB
Newer Older
1
/*
2
 * handling privileged instructions
3
 *
4
 * Copyright IBM Corp. 2008, 2013
5 6 7 8 9 10 11 12 13 14
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License (version 2 only)
 * as published by the Free Software Foundation.
 *
 *    Author(s): Carsten Otte <cotte@de.ibm.com>
 *               Christian Borntraeger <borntraeger@de.ibm.com>
 */

#include <linux/kvm.h>
15
#include <linux/gfp.h>
16
#include <linux/errno.h>
17
#include <linux/compat.h>
18
#include <asm/asm-offsets.h>
19
#include <asm/facility.h>
20 21 22 23
#include <asm/current.h>
#include <asm/debug.h>
#include <asm/ebcdic.h>
#include <asm/sysinfo.h>
24 25 26
#include <asm/pgtable.h>
#include <asm/pgalloc.h>
#include <asm/io.h>
27 28
#include <asm/ptrace.h>
#include <asm/compat.h>
29 30
#include "gaccess.h"
#include "kvm-s390.h"
31
#include "trace.h"
32

33 34 35 36 37
/* Handle SCK (SET CLOCK) interception */
static int handle_set_clock(struct kvm_vcpu *vcpu)
{
	struct kvm_vcpu *cpup;
	s64 hostclk, val;
38
	int i, rc;
39 40 41 42 43 44 45 46
	u64 op2;

	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

	op2 = kvm_s390_get_base_disp_s(vcpu);
	if (op2 & 7)	/* Operand must be on a doubleword boundary */
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
47 48 49
	rc = read_guest(vcpu, op2, &val, sizeof(val));
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

	if (store_tod_clock(&hostclk)) {
		kvm_s390_set_psw_cc(vcpu, 3);
		return 0;
	}
	val = (val - hostclk) & ~0x3fUL;

	mutex_lock(&vcpu->kvm->lock);
	kvm_for_each_vcpu(i, cpup, vcpu->kvm)
		cpup->arch.sie_block->epoch = val;
	mutex_unlock(&vcpu->kvm->lock);

	kvm_s390_set_psw_cc(vcpu, 0);
	return 0;
}

66 67 68
static int handle_set_prefix(struct kvm_vcpu *vcpu)
{
	u64 operand2;
69 70
	u32 address;
	int rc;
71 72 73

	vcpu->stat.instruction_spx++;

74 75 76
	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

77
	operand2 = kvm_s390_get_base_disp_s(vcpu);
78 79

	/* must be word boundary */
80 81
	if (operand2 & 3)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
82 83

	/* get the value */
84 85 86 87 88 89 90 91 92 93 94 95
	rc = read_guest(vcpu, operand2, &address, sizeof(address));
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);

	address &= 0x7fffe000u;

	/*
	 * Make sure the new value is valid memory. We only need to check the
	 * first page, since address is 8k aligned and memory pieces are always
	 * at least 1MB aligned and have at least a size of 1MB.
	 */
	if (kvm_is_error_gpa(vcpu->kvm, address))
96
		return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
97

98
	kvm_s390_set_prefix(vcpu, address);
99 100

	VCPU_EVENT(vcpu, 5, "setting prefix to %x", address);
101
	trace_kvm_s390_handle_prefix(vcpu, 1, address);
102 103 104 105 106 107 108
	return 0;
}

static int handle_store_prefix(struct kvm_vcpu *vcpu)
{
	u64 operand2;
	u32 address;
109
	int rc;
110 111

	vcpu->stat.instruction_stpx++;
112

113 114 115
	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

116
	operand2 = kvm_s390_get_base_disp_s(vcpu);
117 118

	/* must be word boundary */
119 120
	if (operand2 & 3)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
121

122
	address = kvm_s390_get_prefix(vcpu);
123 124

	/* get the value */
125 126 127
	rc = write_guest(vcpu, operand2, &address, sizeof(address));
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
128 129

	VCPU_EVENT(vcpu, 5, "storing prefix to %x", address);
130
	trace_kvm_s390_handle_prefix(vcpu, 0, address);
131 132 133 134 135
	return 0;
}

static int handle_store_cpu_address(struct kvm_vcpu *vcpu)
{
136 137 138
	u16 vcpu_id = vcpu->vcpu_id;
	u64 ga;
	int rc;
139 140

	vcpu->stat.instruction_stap++;
141

142 143 144
	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

145
	ga = kvm_s390_get_base_disp_s(vcpu);
146

147
	if (ga & 1)
148
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
149

150 151 152
	rc = write_guest(vcpu, ga, &vcpu_id, sizeof(vcpu_id));
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
153

154 155
	VCPU_EVENT(vcpu, 5, "storing cpu address to %llx", ga);
	trace_kvm_s390_handle_stap(vcpu, ga);
156 157 158
	return 0;
}

159
static int __skey_check_enable(struct kvm_vcpu *vcpu)
160
{
161
	int rc = 0;
162
	if (!(vcpu->arch.sie_block->ictl & (ICTL_ISKE | ICTL_SSKE | ICTL_RRBE)))
163
		return rc;
164

165
	rc = s390_enable_skey();
166 167
	trace_kvm_s390_skey_related_inst(vcpu);
	vcpu->arch.sie_block->ictl &= ~(ICTL_ISKE | ICTL_SSKE | ICTL_RRBE);
168
	return rc;
169 170 171
}


172 173
static int handle_skey(struct kvm_vcpu *vcpu)
{
174
	int rc = __skey_check_enable(vcpu);
175

176 177
	if (rc)
		return rc;
178
	vcpu->stat.instruction_storage_key++;
179 180 181 182

	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

183
	kvm_s390_rewind_psw(vcpu, 4);
184 185 186 187
	VCPU_EVENT(vcpu, 4, "%s", "retrying storage key operation");
	return 0;
}

188 189 190
static int handle_ipte_interlock(struct kvm_vcpu *vcpu)
{
	vcpu->stat.instruction_ipte_interlock++;
191
	if (psw_bits(vcpu->arch.sie_block->gpsw).p)
192 193
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
	wait_event(vcpu->kvm->arch.ipte_wq, !ipte_lock_held(vcpu));
194
	kvm_s390_rewind_psw(vcpu, 4);
195 196 197 198
	VCPU_EVENT(vcpu, 4, "%s", "retrying ipte interlock operation");
	return 0;
}

T
Thomas Huth 已提交
199 200 201 202 203 204 205 206 207 208
static int handle_test_block(struct kvm_vcpu *vcpu)
{
	gpa_t addr;
	int reg2;

	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

	kvm_s390_get_regs_rre(vcpu, NULL, &reg2);
	addr = vcpu->run->s.regs.gprs[reg2] & PAGE_MASK;
209 210 211
	addr = kvm_s390_logical_to_effective(vcpu, addr);
	if (kvm_s390_check_low_addr_protection(vcpu, addr))
		return kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm);
T
Thomas Huth 已提交
212 213
	addr = kvm_s390_real_to_abs(vcpu, addr);

214
	if (kvm_is_error_gpa(vcpu->kvm, addr))
T
Thomas Huth 已提交
215 216 217 218 219
		return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
	/*
	 * We don't expect errors on modern systems, and do not care
	 * about storage keys (yet), so let's just clear the page.
	 */
220
	if (kvm_clear_guest(vcpu->kvm, addr, PAGE_SIZE))
T
Thomas Huth 已提交
221 222 223 224 225 226
		return -EFAULT;
	kvm_s390_set_psw_cc(vcpu, 0);
	vcpu->run->s.regs.gprs[0] = 0;
	return 0;
}

227
static int handle_tpi(struct kvm_vcpu *vcpu)
228
{
229
	struct kvm_s390_interrupt_info *inti;
H
Heiko Carstens 已提交
230 231 232
	unsigned long len;
	u32 tpi_data[3];
	int cc, rc;
233
	u64 addr;
234

H
Heiko Carstens 已提交
235
	rc = 0;
236
	addr = kvm_s390_get_base_disp_s(vcpu);
237 238
	if (addr & 3)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
239
	cc = 0;
240
	inti = kvm_s390_get_io_int(vcpu->kvm, vcpu->arch.sie_block->gcr[6], 0);
241 242 243
	if (!inti)
		goto no_interrupt;
	cc = 1;
H
Heiko Carstens 已提交
244 245 246
	tpi_data[0] = inti->io.subchannel_id << 16 | inti->io.subchannel_nr;
	tpi_data[1] = inti->io.io_int_parm;
	tpi_data[2] = inti->io.io_int_word;
247 248 249 250 251
	if (addr) {
		/*
		 * Store the two-word I/O interruption code into the
		 * provided area.
		 */
H
Heiko Carstens 已提交
252 253 254 255
		len = sizeof(tpi_data) - 4;
		rc = write_guest(vcpu, addr, &tpi_data, len);
		if (rc)
			return kvm_s390_inject_prog_cond(vcpu, rc);
256 257 258 259 260
	} else {
		/*
		 * Store the three-word I/O interruption code into
		 * the appropriate lowcore area.
		 */
H
Heiko Carstens 已提交
261 262 263
		len = sizeof(tpi_data);
		if (write_guest_lc(vcpu, __LC_SUBCHANNEL_ID, &tpi_data, len))
			rc = -EFAULT;
264
	}
265 266 267 268 269 270 271 272 273
	/*
	 * If we encounter a problem storing the interruption code, the
	 * instruction is suppressed from the guest's view: reinject the
	 * interrupt.
	 */
	if (!rc)
		kfree(inti);
	else
		kvm_s390_reinject_io_int(vcpu->kvm, inti);
274
no_interrupt:
275
	/* Set condition code and we're done. */
H
Heiko Carstens 已提交
276 277 278
	if (!rc)
		kvm_s390_set_psw_cc(vcpu, cc);
	return rc ? -EFAULT : 0;
279 280
}

281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
static int handle_tsch(struct kvm_vcpu *vcpu)
{
	struct kvm_s390_interrupt_info *inti;

	inti = kvm_s390_get_io_int(vcpu->kvm, 0,
				   vcpu->run->s.regs.gprs[1]);

	/*
	 * Prepare exit to userspace.
	 * We indicate whether we dequeued a pending I/O interrupt
	 * so that userspace can re-inject it if the instruction gets
	 * a program check. While this may re-order the pending I/O
	 * interrupts, this is no problem since the priority is kept
	 * intact.
	 */
	vcpu->run->exit_reason = KVM_EXIT_S390_TSCH;
	vcpu->run->s390_tsch.dequeued = !!inti;
	if (inti) {
		vcpu->run->s390_tsch.subchannel_id = inti->io.subchannel_id;
		vcpu->run->s390_tsch.subchannel_nr = inti->io.subchannel_nr;
		vcpu->run->s390_tsch.io_int_parm = inti->io.io_int_parm;
		vcpu->run->s390_tsch.io_int_word = inti->io.io_int_word;
	}
	vcpu->run->s390_tsch.ipb = vcpu->arch.sie_block->ipb;
	kfree(inti);
	return -EREMOTE;
}

static int handle_io_inst(struct kvm_vcpu *vcpu)
{
	VCPU_EVENT(vcpu, 4, "%s", "I/O instruction");

313 314 315
	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

316 317 318 319 320 321 322 323 324 325 326 327 328
	if (vcpu->kvm->arch.css_support) {
		/*
		 * Most I/O instructions will be handled by userspace.
		 * Exceptions are tpi and the interrupt portion of tsch.
		 */
		if (vcpu->arch.sie_block->ipa == 0xb236)
			return handle_tpi(vcpu);
		if (vcpu->arch.sie_block->ipa == 0xb235)
			return handle_tsch(vcpu);
		/* Handle in userspace. */
		return -EOPNOTSUPP;
	} else {
		/*
329
		 * Set condition code 3 to stop the guest from issuing channel
330 331
		 * I/O instructions.
		 */
332
		kvm_s390_set_psw_cc(vcpu, 3);
333 334 335 336
		return 0;
	}
}

337 338 339
static int handle_stfl(struct kvm_vcpu *vcpu)
{
	int rc;
340
	unsigned int fac;
341 342

	vcpu->stat.instruction_stfl++;
343 344 345 346

	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

347 348 349 350
	/*
	 * We need to shift the lower 32 facility bits (bit 0-31) from a u64
	 * into a u32 memory representation. They will remain bits 0-31.
	 */
351
	fac = *vcpu->kvm->arch.model.fac->list >> 32;
352
	rc = write_guest_lc(vcpu, offsetof(struct _lowcore, stfl_fac_list),
353
			    &fac, sizeof(fac));
354
	if (rc)
355
		return rc;
356 357
	VCPU_EVENT(vcpu, 5, "store facility list value %x", fac);
	trace_kvm_s390_handle_stfl(vcpu, fac);
358 359 360
	return 0;
}

361 362
#define PSW_MASK_ADDR_MODE (PSW_MASK_EA | PSW_MASK_BA)
#define PSW_MASK_UNASSIGNED 0xb80800fe7fffffffUL
363
#define PSW_ADDR_24 0x0000000000ffffffUL
364 365
#define PSW_ADDR_31 0x000000007fffffffUL

T
Thomas Huth 已提交
366 367
int is_valid_psw(psw_t *psw)
{
368 369 370 371 372 373 374 375 376 377
	if (psw->mask & PSW_MASK_UNASSIGNED)
		return 0;
	if ((psw->mask & PSW_MASK_ADDR_MODE) == PSW_MASK_BA) {
		if (psw->addr & ~PSW_ADDR_31)
			return 0;
	}
	if (!(psw->mask & PSW_MASK_ADDR_MODE) && (psw->addr & ~PSW_ADDR_24))
		return 0;
	if ((psw->mask & PSW_MASK_ADDR_MODE) ==  PSW_MASK_EA)
		return 0;
T
Thomas Huth 已提交
378 379
	if (psw->addr & 1)
		return 0;
380 381 382
	return 1;
}

383 384
int kvm_s390_handle_lpsw(struct kvm_vcpu *vcpu)
{
385
	psw_t *gpsw = &vcpu->arch.sie_block->gpsw;
386
	psw_compat_t new_psw;
387
	u64 addr;
388
	int rc;
389

390
	if (gpsw->mask & PSW_MASK_PSTATE)
391 392
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

393
	addr = kvm_s390_get_base_disp_s(vcpu);
394 395
	if (addr & 7)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
396 397 398 399

	rc = read_guest(vcpu, addr, &new_psw, sizeof(new_psw));
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
400 401
	if (!(new_psw.mask & PSW32_MASK_BASE))
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
402 403 404 405
	gpsw->mask = (new_psw.mask & ~PSW32_MASK_BASE) << 32;
	gpsw->mask |= new_psw.addr & PSW32_ADDR_AMODE;
	gpsw->addr = new_psw.addr & ~PSW32_ADDR_AMODE;
	if (!is_valid_psw(gpsw))
406
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
407 408 409 410 411 412
	return 0;
}

static int handle_lpswe(struct kvm_vcpu *vcpu)
{
	psw_t new_psw;
413
	u64 addr;
414
	int rc;
415

416 417 418
	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

419
	addr = kvm_s390_get_base_disp_s(vcpu);
420 421
	if (addr & 7)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
422 423 424
	rc = read_guest(vcpu, addr, &new_psw, sizeof(new_psw));
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
425 426
	vcpu->arch.sie_block->gpsw = new_psw;
	if (!is_valid_psw(&vcpu->arch.sie_block->gpsw))
427
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
428 429 430
	return 0;
}

431 432
static int handle_stidp(struct kvm_vcpu *vcpu)
{
433
	u64 stidp_data = vcpu->arch.stidp_data;
434
	u64 operand2;
435
	int rc;
436 437

	vcpu->stat.instruction_stidp++;
438

439 440 441
	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

442
	operand2 = kvm_s390_get_base_disp_s(vcpu);
443

444 445
	if (operand2 & 7)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
446

447 448 449
	rc = write_guest(vcpu, operand2, &stidp_data, sizeof(stidp_data));
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
450 451 452 453 454 455 456 457 458 459

	VCPU_EVENT(vcpu, 5, "%s", "store cpu id");
	return 0;
}

static void handle_stsi_3_2_2(struct kvm_vcpu *vcpu, struct sysinfo_3_2_2 *mem)
{
	int cpus = 0;
	int n;

460
	cpus = atomic_read(&vcpu->kvm->online_vcpus);
461 462

	/* deal with other level 3 hypervisors */
463
	if (stsi(mem, 3, 2, 2))
464 465 466 467 468 469
		mem->count = 0;
	if (mem->count < 8)
		mem->count++;
	for (n = mem->count - 1; n > 0 ; n--)
		memcpy(&mem->vm[n], &mem->vm[n - 1], sizeof(mem->vm[0]));

470
	memset(&mem->vm[0], 0, sizeof(mem->vm[0]));
471 472 473 474 475 476 477 478 479 480 481 482 483
	mem->vm[0].cpus_total = cpus;
	mem->vm[0].cpus_configured = cpus;
	mem->vm[0].cpus_standby = 0;
	mem->vm[0].cpus_reserved = 0;
	mem->vm[0].caf = 1000;
	memcpy(mem->vm[0].name, "KVMguest", 8);
	ASCEBC(mem->vm[0].name, 8);
	memcpy(mem->vm[0].cpi, "KVM/Linux       ", 16);
	ASCEBC(mem->vm[0].cpi, 16);
}

static int handle_stsi(struct kvm_vcpu *vcpu)
{
484 485 486
	int fc = (vcpu->run->s.regs.gprs[0] & 0xf0000000) >> 28;
	int sel1 = vcpu->run->s.regs.gprs[0] & 0xff;
	int sel2 = vcpu->run->s.regs.gprs[1] & 0xffff;
487
	unsigned long mem = 0;
488
	u64 operand2;
489
	int rc = 0;
490 491 492 493

	vcpu->stat.instruction_stsi++;
	VCPU_EVENT(vcpu, 4, "stsi: fc: %x sel1: %x sel2: %x", fc, sel1, sel2);

494 495 496
	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

497
	if (fc > 3) {
498
		kvm_s390_set_psw_cc(vcpu, 3);
499 500
		return 0;
	}
501

502 503
	if (vcpu->run->s.regs.gprs[0] & 0x0fffff00
	    || vcpu->run->s.regs.gprs[1] & 0xffff0000)
504 505
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);

506
	if (fc == 0) {
507
		vcpu->run->s.regs.gprs[0] = 3 << 28;
508
		kvm_s390_set_psw_cc(vcpu, 0);
509
		return 0;
510 511 512 513 514 515 516 517
	}

	operand2 = kvm_s390_get_base_disp_s(vcpu);

	if (operand2 & 0xfff)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);

	switch (fc) {
518 519 520 521
	case 1: /* same handling for 1 and 2 */
	case 2:
		mem = get_zeroed_page(GFP_KERNEL);
		if (!mem)
522
			goto out_no_data;
523
		if (stsi((void *) mem, fc, sel1, sel2))
524
			goto out_no_data;
525 526 527
		break;
	case 3:
		if (sel1 != 2 || sel2 != 2)
528
			goto out_no_data;
529 530
		mem = get_zeroed_page(GFP_KERNEL);
		if (!mem)
531
			goto out_no_data;
532 533 534 535
		handle_stsi_3_2_2(vcpu, (void *) mem);
		break;
	}

536 537 538 539
	rc = write_guest(vcpu, operand2, (void *)mem, PAGE_SIZE);
	if (rc) {
		rc = kvm_s390_inject_prog_cond(vcpu, rc);
		goto out;
540
	}
541
	trace_kvm_s390_handle_stsi(vcpu, fc, sel1, sel2, operand2);
542
	free_page(mem);
543
	kvm_s390_set_psw_cc(vcpu, 0);
544
	vcpu->run->s.regs.gprs[0] = 0;
545
	return 0;
546
out_no_data:
547
	kvm_s390_set_psw_cc(vcpu, 3);
548
out:
549
	free_page(mem);
550
	return rc;
551 552
}

553
static const intercept_handler_t b2_handlers[256] = {
554
	[0x02] = handle_stidp,
555
	[0x04] = handle_set_clock,
556 557 558
	[0x10] = handle_set_prefix,
	[0x11] = handle_store_prefix,
	[0x12] = handle_store_cpu_address,
559
	[0x21] = handle_ipte_interlock,
560 561 562
	[0x29] = handle_skey,
	[0x2a] = handle_skey,
	[0x2b] = handle_skey,
T
Thomas Huth 已提交
563
	[0x2c] = handle_test_block,
564 565 566 567 568 569 570 571 572 573 574 575 576
	[0x30] = handle_io_inst,
	[0x31] = handle_io_inst,
	[0x32] = handle_io_inst,
	[0x33] = handle_io_inst,
	[0x34] = handle_io_inst,
	[0x35] = handle_io_inst,
	[0x36] = handle_io_inst,
	[0x37] = handle_io_inst,
	[0x38] = handle_io_inst,
	[0x39] = handle_io_inst,
	[0x3a] = handle_io_inst,
	[0x3b] = handle_io_inst,
	[0x3c] = handle_io_inst,
577
	[0x50] = handle_ipte_interlock,
578 579 580
	[0x5f] = handle_io_inst,
	[0x74] = handle_io_inst,
	[0x76] = handle_io_inst,
581 582
	[0x7d] = handle_stsi,
	[0xb1] = handle_stfl,
583
	[0xb2] = handle_lpswe,
584 585
};

586
int kvm_s390_handle_b2(struct kvm_vcpu *vcpu)
587 588 589
{
	intercept_handler_t handler;

590
	/*
591 592 593 594
	 * A lot of B2 instructions are priviledged. Here we check for
	 * the privileged ones, that we can handle in the kernel.
	 * Anything else goes to userspace.
	 */
595
	handler = b2_handlers[vcpu->arch.sie_block->ipa & 0x00ff];
596 597 598
	if (handler)
		return handler(vcpu);

599
	return -EOPNOTSUPP;
600
}
601

602 603 604 605
static int handle_epsw(struct kvm_vcpu *vcpu)
{
	int reg1, reg2;

606
	kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);
607 608

	/* This basically extracts the mask half of the psw. */
609
	vcpu->run->s.regs.gprs[reg1] &= 0xffffffff00000000UL;
610 611
	vcpu->run->s.regs.gprs[reg1] |= vcpu->arch.sie_block->gpsw.mask >> 32;
	if (reg2) {
612
		vcpu->run->s.regs.gprs[reg2] &= 0xffffffff00000000UL;
613
		vcpu->run->s.regs.gprs[reg2] |=
614
			vcpu->arch.sie_block->gpsw.mask & 0x00000000ffffffffUL;
615 616 617 618
	}
	return 0;
}

619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
#define PFMF_RESERVED   0xfffc0101UL
#define PFMF_SK         0x00020000UL
#define PFMF_CF         0x00010000UL
#define PFMF_UI         0x00008000UL
#define PFMF_FSC        0x00007000UL
#define PFMF_NQ         0x00000800UL
#define PFMF_MR         0x00000400UL
#define PFMF_MC         0x00000200UL
#define PFMF_KEY        0x000000feUL

static int handle_pfmf(struct kvm_vcpu *vcpu)
{
	int reg1, reg2;
	unsigned long start, end;

	vcpu->stat.instruction_pfmf++;

	kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);

	if (!MACHINE_HAS_PFMF)
		return kvm_s390_inject_program_int(vcpu, PGM_OPERATION);

	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
642
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
643 644 645 646 647

	if (vcpu->run->s.regs.gprs[reg1] & PFMF_RESERVED)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);

	/* Only provide non-quiescing support if the host supports it */
648
	if (vcpu->run->s.regs.gprs[reg1] & PFMF_NQ && !test_facility(14))
649 650 651 652 653 654 655
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);

	/* No support for conditional-SSKE */
	if (vcpu->run->s.regs.gprs[reg1] & (PFMF_MR | PFMF_MC))
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);

	start = vcpu->run->s.regs.gprs[reg2] & PAGE_MASK;
656
	start = kvm_s390_logical_to_effective(vcpu, start);
T
Thomas Huth 已提交
657

658 659 660 661 662 663 664 665 666 667 668 669 670 671
	switch (vcpu->run->s.regs.gprs[reg1] & PFMF_FSC) {
	case 0x00000000:
		end = (start + (1UL << 12)) & ~((1UL << 12) - 1);
		break;
	case 0x00001000:
		end = (start + (1UL << 20)) & ~((1UL << 20) - 1);
		break;
	/* We dont support EDAT2
	case 0x00002000:
		end = (start + (1UL << 31)) & ~((1UL << 31) - 1);
		break;*/
	default:
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
	}
672 673 674 675 676 677

	if (vcpu->run->s.regs.gprs[reg1] & PFMF_CF) {
		if (kvm_s390_check_low_addr_protection(vcpu, start))
			return kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm);
	}

678
	while (start < end) {
T
Thomas Huth 已提交
679 680 681 682 683 684 685 686 687
		unsigned long useraddr, abs_addr;

		/* Translate guest address to host address */
		if ((vcpu->run->s.regs.gprs[reg1] & PFMF_FSC) == 0)
			abs_addr = kvm_s390_real_to_abs(vcpu, start);
		else
			abs_addr = start;
		useraddr = gfn_to_hva(vcpu->kvm, gpa_to_gfn(abs_addr));
		if (kvm_is_error_hva(useraddr))
688 689 690 691 692 693 694 695
			return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);

		if (vcpu->run->s.regs.gprs[reg1] & PFMF_CF) {
			if (clear_user((void __user *)useraddr, PAGE_SIZE))
				return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
		}

		if (vcpu->run->s.regs.gprs[reg1] & PFMF_SK) {
696 697 698 699
			int rc = __skey_check_enable(vcpu);

			if (rc)
				return rc;
700 701 702 703 704 705 706 707 708 709 710 711 712
			if (set_guest_storage_key(current->mm, useraddr,
					vcpu->run->s.regs.gprs[reg1] & PFMF_KEY,
					vcpu->run->s.regs.gprs[reg1] & PFMF_NQ))
				return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
		}

		start += PAGE_SIZE;
	}
	if (vcpu->run->s.regs.gprs[reg1] & PFMF_FSC)
		vcpu->run->s.regs.gprs[reg2] = end;
	return 0;
}

713 714 715 716 717 718 719 720 721 722 723
static int handle_essa(struct kvm_vcpu *vcpu)
{
	/* entries expected to be 1FF */
	int entries = (vcpu->arch.sie_block->cbrlo & ~PAGE_MASK) >> 3;
	unsigned long *cbrlo, cbrle;
	struct gmap *gmap;
	int i;

	VCPU_EVENT(vcpu, 5, "cmma release %d pages", entries);
	gmap = vcpu->arch.gmap;
	vcpu->stat.instruction_essa++;
724
	if (!kvm_s390_cmma_enabled(vcpu->kvm))
725 726 727 728 729 730 731 732 733
		return kvm_s390_inject_program_int(vcpu, PGM_OPERATION);

	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

	if (((vcpu->arch.sie_block->ipb & 0xf0000000) >> 28) > 6)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);

	/* Rewind PSW to repeat the ESSA instruction */
734
	kvm_s390_rewind_psw(vcpu, 4);
735 736 737 738 739 740 741 742 743
	vcpu->arch.sie_block->cbrlo &= PAGE_MASK;	/* reset nceo */
	cbrlo = phys_to_virt(vcpu->arch.sie_block->cbrlo);
	down_read(&gmap->mm->mmap_sem);
	for (i = 0; i < entries; ++i) {
		cbrle = cbrlo[i];
		if (unlikely(cbrle & ~PAGE_MASK || cbrle < 2 * PAGE_SIZE))
			/* invalid entry */
			break;
		/* try to free backing */
744
		__gmap_zap(gmap, cbrle);
745 746 747 748 749 750 751
	}
	up_read(&gmap->mm->mmap_sem);
	if (i < entries)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
	return 0;
}

752
static const intercept_handler_t b9_handlers[256] = {
753
	[0x8a] = handle_ipte_interlock,
754
	[0x8d] = handle_epsw,
755 756
	[0x8e] = handle_ipte_interlock,
	[0x8f] = handle_ipte_interlock,
757
	[0xab] = handle_essa,
758
	[0xaf] = handle_pfmf,
759 760 761 762 763 764 765 766
};

int kvm_s390_handle_b9(struct kvm_vcpu *vcpu)
{
	intercept_handler_t handler;

	/* This is handled just as for the B2 instructions. */
	handler = b9_handlers[vcpu->arch.sie_block->ipa & 0x00ff];
767 768 769
	if (handler)
		return handler(vcpu);

770 771 772
	return -EOPNOTSUPP;
}

773 774 775 776
int kvm_s390_handle_lctl(struct kvm_vcpu *vcpu)
{
	int reg1 = (vcpu->arch.sie_block->ipa & 0x00f0) >> 4;
	int reg3 = vcpu->arch.sie_block->ipa & 0x000f;
777 778
	int reg, rc, nr_regs;
	u32 ctl_array[16];
779
	u64 ga;
780 781 782 783 784 785

	vcpu->stat.instruction_lctl++;

	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

786
	ga = kvm_s390_get_base_disp_rs(vcpu);
787

788
	if (ga & 3)
789 790
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);

791 792
	VCPU_EVENT(vcpu, 5, "lctl r1:%x, r3:%x, addr:%llx", reg1, reg3, ga);
	trace_kvm_s390_handle_lctl(vcpu, 0, reg1, reg3, ga);
793

794 795 796 797
	nr_regs = ((reg3 - reg1) & 0xf) + 1;
	rc = read_guest(vcpu, ga, ctl_array, nr_regs * sizeof(u32));
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
798
	reg = reg1;
799
	nr_regs = 0;
800 801
	do {
		vcpu->arch.sie_block->gcr[reg] &= 0xffffffff00000000ul;
802
		vcpu->arch.sie_block->gcr[reg] |= ctl_array[nr_regs++];
803 804 805 806
		if (reg == reg3)
			break;
		reg = (reg + 1) % 16;
	} while (1);
807
	kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
808 809 810
	return 0;
}

811 812 813 814
int kvm_s390_handle_stctl(struct kvm_vcpu *vcpu)
{
	int reg1 = (vcpu->arch.sie_block->ipa & 0x00f0) >> 4;
	int reg3 = vcpu->arch.sie_block->ipa & 0x000f;
815 816
	int reg, rc, nr_regs;
	u32 ctl_array[16];
817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832
	u64 ga;

	vcpu->stat.instruction_stctl++;

	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

	ga = kvm_s390_get_base_disp_rs(vcpu);

	if (ga & 3)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);

	VCPU_EVENT(vcpu, 5, "stctl r1:%x, r3:%x, addr:%llx", reg1, reg3, ga);
	trace_kvm_s390_handle_stctl(vcpu, 0, reg1, reg3, ga);

	reg = reg1;
833
	nr_regs = 0;
834
	do {
835
		ctl_array[nr_regs++] = vcpu->arch.sie_block->gcr[reg];
836 837 838 839
		if (reg == reg3)
			break;
		reg = (reg + 1) % 16;
	} while (1);
840 841
	rc = write_guest(vcpu, ga, ctl_array, nr_regs * sizeof(u32));
	return rc ? kvm_s390_inject_prog_cond(vcpu, rc) : 0;
842 843
}

844 845 846 847
static int handle_lctlg(struct kvm_vcpu *vcpu)
{
	int reg1 = (vcpu->arch.sie_block->ipa & 0x00f0) >> 4;
	int reg3 = vcpu->arch.sie_block->ipa & 0x000f;
848 849 850
	int reg, rc, nr_regs;
	u64 ctl_array[16];
	u64 ga;
851 852 853 854 855 856

	vcpu->stat.instruction_lctlg++;

	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

857
	ga = kvm_s390_get_base_disp_rsy(vcpu);
858

859
	if (ga & 7)
860 861
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);

862 863
	VCPU_EVENT(vcpu, 5, "lctlg r1:%x, r3:%x, addr:%llx", reg1, reg3, ga);
	trace_kvm_s390_handle_lctl(vcpu, 1, reg1, reg3, ga);
864

865 866 867 868 869 870
	nr_regs = ((reg3 - reg1) & 0xf) + 1;
	rc = read_guest(vcpu, ga, ctl_array, nr_regs * sizeof(u64));
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
	reg = reg1;
	nr_regs = 0;
871
	do {
872
		vcpu->arch.sie_block->gcr[reg] = ctl_array[nr_regs++];
873 874 875 876
		if (reg == reg3)
			break;
		reg = (reg + 1) % 16;
	} while (1);
877
	kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
878 879 880
	return 0;
}

881 882 883 884
static int handle_stctg(struct kvm_vcpu *vcpu)
{
	int reg1 = (vcpu->arch.sie_block->ipa & 0x00f0) >> 4;
	int reg3 = vcpu->arch.sie_block->ipa & 0x000f;
885 886 887
	int reg, rc, nr_regs;
	u64 ctl_array[16];
	u64 ga;
888 889 890 891 892 893 894 895 896 897 898 899 900 901

	vcpu->stat.instruction_stctg++;

	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

	ga = kvm_s390_get_base_disp_rsy(vcpu);

	if (ga & 7)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);

	VCPU_EVENT(vcpu, 5, "stctg r1:%x, r3:%x, addr:%llx", reg1, reg3, ga);
	trace_kvm_s390_handle_stctl(vcpu, 1, reg1, reg3, ga);

902 903
	reg = reg1;
	nr_regs = 0;
904
	do {
905
		ctl_array[nr_regs++] = vcpu->arch.sie_block->gcr[reg];
906 907 908 909
		if (reg == reg3)
			break;
		reg = (reg + 1) % 16;
	} while (1);
910 911
	rc = write_guest(vcpu, ga, ctl_array, nr_regs * sizeof(u64));
	return rc ? kvm_s390_inject_prog_cond(vcpu, rc) : 0;
912 913
}

914
static const intercept_handler_t eb_handlers[256] = {
915
	[0x2f] = handle_lctlg,
916
	[0x25] = handle_stctg,
917 918
};

919
int kvm_s390_handle_eb(struct kvm_vcpu *vcpu)
920 921 922 923 924 925 926 927 928
{
	intercept_handler_t handler;

	handler = eb_handlers[vcpu->arch.sie_block->ipb & 0xff];
	if (handler)
		return handler(vcpu);
	return -EOPNOTSUPP;
}

929 930
static int handle_tprot(struct kvm_vcpu *vcpu)
{
931
	u64 address1, address2;
932 933 934
	unsigned long hva, gpa;
	int ret = 0, cc = 0;
	bool writable;
935 936 937

	vcpu->stat.instruction_tprot++;

938 939 940
	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

941 942
	kvm_s390_get_base_disp_sse(vcpu, &address1, &address2);

943 944 945 946 947 948
	/* we only handle the Linux memory detection case:
	 * access key == 0
	 * everything else goes to userspace. */
	if (address2 & 0xf0)
		return -EOPNOTSUPP;
	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_DAT)
949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965
		ipte_lock(vcpu);
	ret = guest_translate_address(vcpu, address1, &gpa, 1);
	if (ret == PGM_PROTECTION) {
		/* Write protected? Try again with read-only... */
		cc = 1;
		ret = guest_translate_address(vcpu, address1, &gpa, 0);
	}
	if (ret) {
		if (ret == PGM_ADDRESSING || ret == PGM_TRANSLATION_SPEC) {
			ret = kvm_s390_inject_program_int(vcpu, ret);
		} else if (ret > 0) {
			/* Translation not available */
			kvm_s390_set_psw_cc(vcpu, 3);
			ret = 0;
		}
		goto out_unlock;
	}
966

967 968 969 970 971 972 973 974 975 976 977 978 979
	hva = gfn_to_hva_prot(vcpu->kvm, gpa_to_gfn(gpa), &writable);
	if (kvm_is_error_hva(hva)) {
		ret = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
	} else {
		if (!writable)
			cc = 1;		/* Write not permitted ==> read-only */
		kvm_s390_set_psw_cc(vcpu, cc);
		/* Note: CC2 only occurs for storage keys (not supported yet) */
	}
out_unlock:
	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_DAT)
		ipte_unlock(vcpu);
	return ret;
980 981 982 983 984 985 986 987 988 989
}

int kvm_s390_handle_e5(struct kvm_vcpu *vcpu)
{
	/* For e5xx... instructions we only handle TPROT */
	if ((vcpu->arch.sie_block->ipa & 0x00ff) == 0x01)
		return handle_tprot(vcpu);
	return -EOPNOTSUPP;
}

990 991 992 993 994
static int handle_sckpf(struct kvm_vcpu *vcpu)
{
	u32 value;

	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
995
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
996 997 998 999 1000 1001 1002 1003 1004 1005 1006

	if (vcpu->run->s.regs.gprs[0] & 0x00000000ffff0000)
		return kvm_s390_inject_program_int(vcpu,
						   PGM_SPECIFICATION);

	value = vcpu->run->s.regs.gprs[0] & 0x000000000000ffff;
	vcpu->arch.sie_block->todpr = value;

	return 0;
}

1007
static const intercept_handler_t x01_handlers[256] = {
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019
	[0x07] = handle_sckpf,
};

int kvm_s390_handle_01(struct kvm_vcpu *vcpu)
{
	intercept_handler_t handler;

	handler = x01_handlers[vcpu->arch.sie_block->ipa & 0x00ff];
	if (handler)
		return handler(vcpu);
	return -EOPNOTSUPP;
}