priv.c 26.2 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 123 124 125

	address = vcpu->arch.sie_block->prefix;
	address = address & 0x7fffe000u;

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

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

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

	vcpu->stat.instruction_stap++;
142

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

146
	ga = kvm_s390_get_base_disp_s(vcpu);
147

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

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

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

160 161 162 163 164 165 166 167 168 169 170
static void __skey_check_enable(struct kvm_vcpu *vcpu)
{
	if (!(vcpu->arch.sie_block->ictl & (ICTL_ISKE | ICTL_SSKE | ICTL_RRBE)))
		return;

	s390_enable_skey();
	trace_kvm_s390_skey_related_inst(vcpu);
	vcpu->arch.sie_block->ictl &= ~(ICTL_ISKE | ICTL_SSKE | ICTL_RRBE);
}


171 172
static int handle_skey(struct kvm_vcpu *vcpu)
{
173 174
	__skey_check_enable(vcpu);

175
	vcpu->stat.instruction_storage_key++;
176 177 178 179

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

180 181
	vcpu->arch.sie_block->gpsw.addr =
		__rewind_psw(vcpu->arch.sie_block->gpsw, 4);
182 183 184 185
	VCPU_EVENT(vcpu, 4, "%s", "retrying storage key operation");
	return 0;
}

186 187 188 189 190 191 192 193 194 195 196 197 198
static int handle_ipte_interlock(struct kvm_vcpu *vcpu)
{
	psw_t *psw = &vcpu->arch.sie_block->gpsw;

	vcpu->stat.instruction_ipte_interlock++;
	if (psw_bits(*psw).p)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
	wait_event(vcpu->kvm->arch.ipte_wq, !ipte_lock_held(vcpu));
	psw->addr = __rewind_psw(*psw, 4);
	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 340 341
static int handle_stfl(struct kvm_vcpu *vcpu)
{
	int rc;

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

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

346 347
	rc = write_guest_lc(vcpu, offsetof(struct _lowcore, stfl_fac_list),
			    vfacilities, 4);
348
	if (rc)
349
		return rc;
350 351 352
	VCPU_EVENT(vcpu, 5, "store facility list value %x",
		   *(unsigned int *) vfacilities);
	trace_kvm_s390_handle_stfl(vcpu, *(unsigned int *) vfacilities);
353 354 355
	return 0;
}

356 357 358 359 360 361 362 363 364
static void handle_new_psw(struct kvm_vcpu *vcpu)
{
	/* Check whether the new psw is enabled for machine checks. */
	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_MCHECK)
		kvm_s390_deliver_pending_machine_checks(vcpu);
}

#define PSW_MASK_ADDR_MODE (PSW_MASK_EA | PSW_MASK_BA)
#define PSW_MASK_UNASSIGNED 0xb80800fe7fffffffUL
365
#define PSW_ADDR_24 0x0000000000ffffffUL
366 367
#define PSW_ADDR_31 0x000000007fffffffUL

T
Thomas Huth 已提交
368 369
int is_valid_psw(psw_t *psw)
{
370 371 372 373 374 375 376 377 378 379
	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 已提交
380 381
	if (psw->addr & 1)
		return 0;
382 383 384
	return 1;
}

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

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

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

	rc = read_guest(vcpu, addr, &new_psw, sizeof(new_psw));
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
402 403
	if (!(new_psw.mask & PSW32_MASK_BASE))
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
404 405 406 407
	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))
408
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
409 410 411 412 413 414 415
	handle_new_psw(vcpu);
	return 0;
}

static int handle_lpswe(struct kvm_vcpu *vcpu)
{
	psw_t new_psw;
416
	u64 addr;
417
	int rc;
418

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

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

435 436
static int handle_stidp(struct kvm_vcpu *vcpu)
{
437
	u64 stidp_data = vcpu->arch.stidp_data;
438
	u64 operand2;
439
	int rc;
440 441

	vcpu->stat.instruction_stidp++;
442

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

446
	operand2 = kvm_s390_get_base_disp_s(vcpu);
447

448 449
	if (operand2 & 7)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
450

451 452 453
	rc = write_guest(vcpu, operand2, &stidp_data, sizeof(stidp_data));
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
454 455 456 457 458 459 460 461 462 463

	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;

464
	cpus = atomic_read(&vcpu->kvm->online_vcpus);
465 466

	/* deal with other level 3 hypervisors */
467
	if (stsi(mem, 3, 2, 2))
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
		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]));

	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)
{
487 488 489
	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;
490
	unsigned long mem = 0;
491
	u64 operand2;
492
	int rc = 0;
493 494 495 496

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

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

500
	if (fc > 3) {
501
		kvm_s390_set_psw_cc(vcpu, 3);
502 503
		return 0;
	}
504

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

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

	operand2 = kvm_s390_get_base_disp_s(vcpu);

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

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

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

556
static const intercept_handler_t b2_handlers[256] = {
557
	[0x02] = handle_stidp,
558
	[0x04] = handle_set_clock,
559 560 561
	[0x10] = handle_set_prefix,
	[0x11] = handle_store_prefix,
	[0x12] = handle_store_cpu_address,
562
	[0x21] = handle_ipte_interlock,
563 564 565
	[0x29] = handle_skey,
	[0x2a] = handle_skey,
	[0x2b] = handle_skey,
T
Thomas Huth 已提交
566
	[0x2c] = handle_test_block,
567 568 569 570 571 572 573 574 575 576 577 578 579
	[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,
580
	[0x50] = handle_ipte_interlock,
581 582 583
	[0x5f] = handle_io_inst,
	[0x74] = handle_io_inst,
	[0x76] = handle_io_inst,
584 585
	[0x7d] = handle_stsi,
	[0xb1] = handle_stfl,
586
	[0xb2] = handle_lpswe,
587 588
};

589
int kvm_s390_handle_b2(struct kvm_vcpu *vcpu)
590 591 592
{
	intercept_handler_t handler;

593
	/*
594 595 596 597
	 * 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.
	 */
598
	handler = b2_handlers[vcpu->arch.sie_block->ipa & 0x00ff];
599 600 601
	if (handler)
		return handler(vcpu);

602
	return -EOPNOTSUPP;
603
}
604

605 606 607 608
static int handle_epsw(struct kvm_vcpu *vcpu)
{
	int reg1, reg2;

609
	kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);
610 611

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

622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644
#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)
645
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
646 647 648 649 650

	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 */
651
	if (vcpu->run->s.regs.gprs[reg1] & PFMF_NQ && !test_facility(14))
652 653 654 655 656 657 658
		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;
T
Thomas Huth 已提交
659 660 661 662 663
	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);
	}

664 665 666 667 668 669 670 671 672 673 674 675 676 677 678
	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);
	}
	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
			__skey_check_enable(vcpu);
697 698 699 700 701 702 703 704 705 706 707 708 709
			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;
}

710 711 712 713 714 715 716 717 718 719 720
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++;
721
	if (!kvm_s390_cmma_enabled(vcpu->kvm))
722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749
		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 */
	vcpu->arch.sie_block->gpsw.addr =
		__rewind_psw(vcpu->arch.sie_block->gpsw, 4);
	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 */
		__gmap_zap(cbrle, gmap);
	}
	up_read(&gmap->mm->mmap_sem);
	if (i < entries)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
	return 0;
}

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

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];
765 766 767
	if (handler)
		return handler(vcpu);

768 769 770
	return -EOPNOTSUPP;
}

771 772 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;
	u32 val = 0;
	int reg, rc;
777
	u64 ga;
778 779 780 781 782 783

	vcpu->stat.instruction_lctl++;

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

784
	ga = kvm_s390_get_base_disp_rs(vcpu);
785

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

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

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

	return 0;
}

808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
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;
	u64 ga;
	u32 val;
	int reg, rc;

	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;
	do {
		val = vcpu->arch.sie_block->gcr[reg] &  0x00000000fffffffful;
		rc = write_guest(vcpu, ga, &val, sizeof(val));
		if (rc)
			return kvm_s390_inject_prog_cond(vcpu, rc);
		ga += 4;
		if (reg == reg3)
			break;
		reg = (reg + 1) % 16;
	} while (1);

	return 0;
}

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
	u64 ga, val;
849 850 851 852 853 854 855
	int reg, rc;

	vcpu->stat.instruction_lctlg++;

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

856
	ga = kvm_s390_get_base_disp_rsy(vcpu);
857

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

	reg = reg1;

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

	do {
867
		rc = read_guest(vcpu, ga, &val, sizeof(val));
868
		if (rc)
869 870 871
			return kvm_s390_inject_prog_cond(vcpu, rc);
		vcpu->arch.sie_block->gcr[reg] = val;
		ga += 8;
872 873 874 875 876 877 878 879
		if (reg == reg3)
			break;
		reg = (reg + 1) % 16;
	} while (1);

	return 0;
}

880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915
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;
	u64 ga, val;
	int reg, rc;

	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);

	reg = reg1;

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

	do {
		val = vcpu->arch.sie_block->gcr[reg];
		rc = write_guest(vcpu, ga, &val, sizeof(val));
		if (rc)
			return kvm_s390_inject_prog_cond(vcpu, rc);
		ga += 8;
		if (reg == reg3)
			break;
		reg = (reg + 1) % 16;
	} while (1);

	return 0;
}

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

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

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

931 932
static int handle_tprot(struct kvm_vcpu *vcpu)
{
933
	u64 address1, address2;
934
	struct vm_area_struct *vma;
935
	unsigned long user_address;
936 937 938

	vcpu->stat.instruction_tprot++;

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

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

944 945 946 947 948 949 950 951 952 953
	/* we only handle the Linux memory detection case:
	 * access key == 0
	 * guest DAT == off
	 * everything else goes to userspace. */
	if (address2 & 0xf0)
		return -EOPNOTSUPP;
	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_DAT)
		return -EOPNOTSUPP;

	down_read(&current->mm->mmap_sem);
954 955 956
	user_address = __gmap_translate(address1, vcpu->arch.gmap);
	if (IS_ERR_VALUE(user_address))
		goto out_inject;
957
	vma = find_vma(current->mm, user_address);
958 959
	if (!vma)
		goto out_inject;
960 961 962 963 964 965 966 967
	vcpu->arch.sie_block->gpsw.mask &= ~(3ul << 44);
	if (!(vma->vm_flags & VM_WRITE) && (vma->vm_flags & VM_READ))
		vcpu->arch.sie_block->gpsw.mask |= (1ul << 44);
	if (!(vma->vm_flags & VM_WRITE) && !(vma->vm_flags & VM_READ))
		vcpu->arch.sie_block->gpsw.mask |= (2ul << 44);

	up_read(&current->mm->mmap_sem);
	return 0;
968 969 970 971

out_inject:
	up_read(&current->mm->mmap_sem);
	return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
972 973 974 975 976 977 978 979 980 981
}

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;
}

982 983 984 985 986
static int handle_sckpf(struct kvm_vcpu *vcpu)
{
	u32 value;

	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
987
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
988 989 990 991 992 993 994 995 996 997 998

	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;
}

999
static const intercept_handler_t x01_handlers[256] = {
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
	[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;
}