priv.c 32.4 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 19
#include <linux/mm_types.h>

20
#include <asm/asm-offsets.h>
21
#include <asm/facility.h>
22 23 24 25
#include <asm/current.h>
#include <asm/debug.h>
#include <asm/ebcdic.h>
#include <asm/sysinfo.h>
26 27
#include <asm/pgtable.h>
#include <asm/pgalloc.h>
28
#include <asm/gmap.h>
29
#include <asm/io.h>
30 31
#include <asm/ptrace.h>
#include <asm/compat.h>
32
#include <asm/sclp.h>
33 34
#include "gaccess.h"
#include "kvm-s390.h"
35
#include "trace.h"
36

F
Fan Zhang 已提交
37 38 39
static int handle_ri(struct kvm_vcpu *vcpu)
{
	if (test_kvm_facility(vcpu->kvm, 64)) {
40
		VCPU_EVENT(vcpu, 3, "%s", "ENABLE: RI (lazy)");
F
Fan Zhang 已提交
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
		vcpu->arch.sie_block->ecb3 |= 0x01;
		kvm_s390_retry_instr(vcpu);
		return 0;
	} else
		return kvm_s390_inject_program_int(vcpu, PGM_OPERATION);
}

int kvm_s390_handle_aa(struct kvm_vcpu *vcpu)
{
	if ((vcpu->arch.sie_block->ipa & 0xf) <= 4)
		return handle_ri(vcpu);
	else
		return -EOPNOTSUPP;
}

56 57 58
/* Handle SCK (SET CLOCK) interception */
static int handle_set_clock(struct kvm_vcpu *vcpu)
{
59
	int rc;
60
	u8 ar;
61
	u64 op2, val;
62 63 64 65

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

66
	op2 = kvm_s390_get_base_disp_s(vcpu, &ar);
67 68
	if (op2 & 7)	/* Operand must be on a doubleword boundary */
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
69
	rc = read_guest(vcpu, op2, ar, &val, sizeof(val));
70 71
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
72

73
	VCPU_EVENT(vcpu, 3, "SCK: setting guest TOD to 0x%llx", val);
74
	kvm_s390_set_tod_clock(vcpu->kvm, val);
75 76 77 78 79

	kvm_s390_set_psw_cc(vcpu, 0);
	return 0;
}

80 81 82
static int handle_set_prefix(struct kvm_vcpu *vcpu)
{
	u64 operand2;
83 84
	u32 address;
	int rc;
85
	u8 ar;
86 87 88

	vcpu->stat.instruction_spx++;

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

92
	operand2 = kvm_s390_get_base_disp_s(vcpu, &ar);
93 94

	/* must be word boundary */
95 96
	if (operand2 & 3)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
97 98

	/* get the value */
99
	rc = read_guest(vcpu, operand2, ar, &address, sizeof(address));
100 101 102 103 104 105 106 107 108 109 110
	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))
111
		return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
112

113
	kvm_s390_set_prefix(vcpu, address);
114
	trace_kvm_s390_handle_prefix(vcpu, 1, address);
115 116 117 118 119 120 121
	return 0;
}

static int handle_store_prefix(struct kvm_vcpu *vcpu)
{
	u64 operand2;
	u32 address;
122
	int rc;
123
	u8 ar;
124 125

	vcpu->stat.instruction_stpx++;
126

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

130
	operand2 = kvm_s390_get_base_disp_s(vcpu, &ar);
131 132

	/* must be word boundary */
133 134
	if (operand2 & 3)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
135

136
	address = kvm_s390_get_prefix(vcpu);
137 138

	/* get the value */
139
	rc = write_guest(vcpu, operand2, ar, &address, sizeof(address));
140 141
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
142

143
	VCPU_EVENT(vcpu, 3, "STPX: storing prefix 0x%x into 0x%llx", address, operand2);
144
	trace_kvm_s390_handle_prefix(vcpu, 0, address);
145 146 147 148 149
	return 0;
}

static int handle_store_cpu_address(struct kvm_vcpu *vcpu)
{
150 151 152
	u16 vcpu_id = vcpu->vcpu_id;
	u64 ga;
	int rc;
153
	u8 ar;
154 155

	vcpu->stat.instruction_stap++;
156

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

160
	ga = kvm_s390_get_base_disp_s(vcpu, &ar);
161

162
	if (ga & 1)
163
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
164

165
	rc = write_guest(vcpu, ga, ar, &vcpu_id, sizeof(vcpu_id));
166 167
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
168

169
	VCPU_EVENT(vcpu, 3, "STAP: storing cpu address (%u) to 0x%llx", vcpu_id, ga);
170
	trace_kvm_s390_handle_stap(vcpu, ga);
171 172 173
	return 0;
}

174
static int __skey_check_enable(struct kvm_vcpu *vcpu)
175
{
176
	int rc = 0;
177 178

	trace_kvm_s390_skey_related_inst(vcpu);
179
	if (!(vcpu->arch.sie_block->ictl & (ICTL_ISKE | ICTL_SSKE | ICTL_RRBE)))
180
		return rc;
181

182
	rc = s390_enable_skey();
183 184 185
	VCPU_EVENT(vcpu, 3, "enabling storage keys for guest: %d", rc);
	if (!rc)
		vcpu->arch.sie_block->ictl &= ~(ICTL_ISKE | ICTL_SSKE | ICTL_RRBE);
186
	return rc;
187 188
}

189
static int try_handle_skey(struct kvm_vcpu *vcpu)
190
{
191
	int rc;
192

193 194
	vcpu->stat.instruction_storage_key++;
	rc = __skey_check_enable(vcpu);
195 196
	if (rc)
		return rc;
197 198 199 200 201 202
	if (sclp.has_skey) {
		/* with storage-key facility, SIE interprets it for us */
		kvm_s390_retry_instr(vcpu);
		VCPU_EVENT(vcpu, 4, "%s", "retrying storage key operation");
		return -EAGAIN;
	}
203 204
	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
205 206
	return 0;
}
207

208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 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 313 314 315 316
static int handle_iske(struct kvm_vcpu *vcpu)
{
	unsigned long addr;
	unsigned char key;
	int reg1, reg2;
	int rc;

	rc = try_handle_skey(vcpu);
	if (rc)
		return rc != -EAGAIN ? rc : 0;

	kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);

	addr = vcpu->run->s.regs.gprs[reg2] & PAGE_MASK;
	addr = kvm_s390_logical_to_effective(vcpu, addr);
	addr = kvm_s390_real_to_abs(vcpu, addr);
	addr = gfn_to_hva(vcpu->kvm, gpa_to_gfn(addr));
	if (kvm_is_error_hva(addr))
		return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);

	down_read(&current->mm->mmap_sem);
	rc = get_guest_storage_key(current->mm, addr, &key);
	up_read(&current->mm->mmap_sem);
	if (rc)
		return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
	vcpu->run->s.regs.gprs[reg1] &= ~0xff;
	vcpu->run->s.regs.gprs[reg1] |= key;
	return 0;
}

static int handle_rrbe(struct kvm_vcpu *vcpu)
{
	unsigned long addr;
	int reg1, reg2;
	int rc;

	rc = try_handle_skey(vcpu);
	if (rc)
		return rc != -EAGAIN ? rc : 0;

	kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);

	addr = vcpu->run->s.regs.gprs[reg2] & PAGE_MASK;
	addr = kvm_s390_logical_to_effective(vcpu, addr);
	addr = kvm_s390_real_to_abs(vcpu, addr);
	addr = gfn_to_hva(vcpu->kvm, gpa_to_gfn(addr));
	if (kvm_is_error_hva(addr))
		return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);

	down_read(&current->mm->mmap_sem);
	rc = reset_guest_reference_bit(current->mm, addr);
	up_read(&current->mm->mmap_sem);
	if (rc < 0)
		return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);

	kvm_s390_set_psw_cc(vcpu, rc);
	return 0;
}

#define SSKE_NQ 0x8
#define SSKE_MR 0x4
#define SSKE_MC 0x2
#define SSKE_MB 0x1
static int handle_sske(struct kvm_vcpu *vcpu)
{
	unsigned char m3 = vcpu->arch.sie_block->ipb >> 28;
	unsigned long start, end;
	unsigned char key, oldkey;
	int reg1, reg2;
	int rc;

	rc = try_handle_skey(vcpu);
	if (rc)
		return rc != -EAGAIN ? rc : 0;

	if (!test_kvm_facility(vcpu->kvm, 8))
		m3 &= ~SSKE_MB;
	if (!test_kvm_facility(vcpu->kvm, 10))
		m3 &= ~(SSKE_MC | SSKE_MR);
	if (!test_kvm_facility(vcpu->kvm, 14))
		m3 &= ~SSKE_NQ;

	kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);

	key = vcpu->run->s.regs.gprs[reg1] & 0xfe;
	start = vcpu->run->s.regs.gprs[reg2] & PAGE_MASK;
	start = kvm_s390_logical_to_effective(vcpu, start);
	if (m3 & SSKE_MB) {
		/* start already designates an absolute address */
		end = (start + (1UL << 20)) & ~((1UL << 20) - 1);
	} else {
		start = kvm_s390_real_to_abs(vcpu, start);
		end = start + PAGE_SIZE;
	}

	while (start != end) {
		unsigned long addr = gfn_to_hva(vcpu->kvm, gpa_to_gfn(start));

		if (kvm_is_error_hva(addr))
			return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);

		down_read(&current->mm->mmap_sem);
		rc = cond_set_guest_storage_key(current->mm, addr, key, &oldkey,
						m3 & SSKE_NQ, m3 & SSKE_MR,
						m3 & SSKE_MC);
		up_read(&current->mm->mmap_sem);
		if (rc < 0)
			return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
		start += PAGE_SIZE;
317
	}
318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336

	if (m3 & (SSKE_MC | SSKE_MR)) {
		if (m3 & SSKE_MB) {
			/* skey in reg1 is unpredictable */
			kvm_s390_set_psw_cc(vcpu, 3);
		} else {
			kvm_s390_set_psw_cc(vcpu, rc);
			vcpu->run->s.regs.gprs[reg1] &= ~0xff00UL;
			vcpu->run->s.regs.gprs[reg1] |= (u64) oldkey << 8;
		}
	}
	if (m3 & SSKE_MB) {
		if (psw_bits(vcpu->arch.sie_block->gpsw).eaba == PSW_AMODE_64BIT)
			vcpu->run->s.regs.gprs[reg2] &= ~PAGE_MASK;
		else
			vcpu->run->s.regs.gprs[reg2] &= ~0xfffff000UL;
		end = kvm_s390_logical_to_effective(vcpu, end);
		vcpu->run->s.regs.gprs[reg2] |= end;
	}
337 338 339
	return 0;
}

340 341 342
static int handle_ipte_interlock(struct kvm_vcpu *vcpu)
{
	vcpu->stat.instruction_ipte_interlock++;
343
	if (psw_bits(vcpu->arch.sie_block->gpsw).p)
344 345
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
	wait_event(vcpu->kvm->arch.ipte_wq, !ipte_lock_held(vcpu));
346
	kvm_s390_retry_instr(vcpu);
347 348 349 350
	VCPU_EVENT(vcpu, 4, "%s", "retrying ipte interlock operation");
	return 0;
}

T
Thomas Huth 已提交
351 352 353 354 355 356 357 358 359 360
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;
361
	addr = kvm_s390_logical_to_effective(vcpu, addr);
362
	if (kvm_s390_check_low_addr_prot_real(vcpu, addr))
363
		return kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm);
T
Thomas Huth 已提交
364 365
	addr = kvm_s390_real_to_abs(vcpu, addr);

366
	if (kvm_is_error_gpa(vcpu->kvm, addr))
T
Thomas Huth 已提交
367 368 369 370 371
		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.
	 */
372
	if (kvm_clear_guest(vcpu->kvm, addr, PAGE_SIZE))
T
Thomas Huth 已提交
373 374 375 376 377 378
		return -EFAULT;
	kvm_s390_set_psw_cc(vcpu, 0);
	vcpu->run->s.regs.gprs[0] = 0;
	return 0;
}

379
static int handle_tpi(struct kvm_vcpu *vcpu)
380
{
381
	struct kvm_s390_interrupt_info *inti;
H
Heiko Carstens 已提交
382 383
	unsigned long len;
	u32 tpi_data[3];
384
	int rc;
385
	u64 addr;
386
	u8 ar;
387

388
	addr = kvm_s390_get_base_disp_s(vcpu, &ar);
389 390
	if (addr & 3)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
391

392
	inti = kvm_s390_get_io_int(vcpu->kvm, vcpu->arch.sie_block->gcr[6], 0);
393 394 395 396 397
	if (!inti) {
		kvm_s390_set_psw_cc(vcpu, 0);
		return 0;
	}

H
Heiko Carstens 已提交
398 399 400
	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;
401 402 403 404 405
	if (addr) {
		/*
		 * Store the two-word I/O interruption code into the
		 * provided area.
		 */
H
Heiko Carstens 已提交
406
		len = sizeof(tpi_data) - 4;
407
		rc = write_guest(vcpu, addr, ar, &tpi_data, len);
408 409 410 411
		if (rc) {
			rc = kvm_s390_inject_prog_cond(vcpu, rc);
			goto reinject_interrupt;
		}
412 413 414 415 416
	} else {
		/*
		 * Store the three-word I/O interruption code into
		 * the appropriate lowcore area.
		 */
H
Heiko Carstens 已提交
417
		len = sizeof(tpi_data);
418 419
		if (write_guest_lc(vcpu, __LC_SUBCHANNEL_ID, &tpi_data, len)) {
			/* failed writes to the low core are not recoverable */
H
Heiko Carstens 已提交
420
			rc = -EFAULT;
421 422
			goto reinject_interrupt;
		}
423
	}
424 425 426 427 428 429

	/* irq was successfully handed to the guest */
	kfree(inti);
	kvm_s390_set_psw_cc(vcpu, 1);
	return 0;
reinject_interrupt:
430 431 432 433 434
	/*
	 * If we encounter a problem storing the interruption code, the
	 * instruction is suppressed from the guest's view: reinject the
	 * interrupt.
	 */
435 436 437 438
	if (kvm_s390_reinject_io_int(vcpu->kvm, inti)) {
		kfree(inti);
		rc = -EFAULT;
	}
439
	/* don't set the cc, a pgm irq was injected or we drop to user space */
H
Heiko Carstens 已提交
440
	return rc ? -EFAULT : 0;
441 442
}

443 444
static int handle_tsch(struct kvm_vcpu *vcpu)
{
445 446
	struct kvm_s390_interrupt_info *inti = NULL;
	const u64 isc_mask = 0xffUL << 24; /* all iscs set */
447

448 449 450 451
	/* a valid schid has at least one bit set */
	if (vcpu->run->s.regs.gprs[1])
		inti = kvm_s390_get_io_int(vcpu->kvm, isc_mask,
					   vcpu->run->s.regs.gprs[1]);
452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477

	/*
	 * 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");

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

481 482 483 484 485 486 487 488 489 490 491 492 493
	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 {
		/*
494
		 * Set condition code 3 to stop the guest from issuing channel
495 496
		 * I/O instructions.
		 */
497
		kvm_s390_set_psw_cc(vcpu, 3);
498 499 500 501
		return 0;
	}
}

502 503 504
static int handle_stfl(struct kvm_vcpu *vcpu)
{
	int rc;
505
	unsigned int fac;
506 507

	vcpu->stat.instruction_stfl++;
508 509 510 511

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

512 513 514 515
	/*
	 * 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.
	 */
516
	fac = *vcpu->kvm->arch.model.fac_list >> 32;
517
	rc = write_guest_lc(vcpu, offsetof(struct lowcore, stfl_fac_list),
518
			    &fac, sizeof(fac));
519
	if (rc)
520
		return rc;
521
	VCPU_EVENT(vcpu, 3, "STFL: store facility list 0x%x", fac);
522
	trace_kvm_s390_handle_stfl(vcpu, fac);
523 524 525
	return 0;
}

526 527
#define PSW_MASK_ADDR_MODE (PSW_MASK_EA | PSW_MASK_BA)
#define PSW_MASK_UNASSIGNED 0xb80800fe7fffffffUL
528
#define PSW_ADDR_24 0x0000000000ffffffUL
529 530
#define PSW_ADDR_31 0x000000007fffffffUL

T
Thomas Huth 已提交
531 532
int is_valid_psw(psw_t *psw)
{
533 534 535 536 537 538 539 540 541 542
	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 已提交
543 544
	if (psw->addr & 1)
		return 0;
545 546 547
	return 1;
}

548 549
int kvm_s390_handle_lpsw(struct kvm_vcpu *vcpu)
{
550
	psw_t *gpsw = &vcpu->arch.sie_block->gpsw;
551
	psw_compat_t new_psw;
552
	u64 addr;
553
	int rc;
554
	u8 ar;
555

556
	if (gpsw->mask & PSW_MASK_PSTATE)
557 558
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

559
	addr = kvm_s390_get_base_disp_s(vcpu, &ar);
560 561
	if (addr & 7)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
562

563
	rc = read_guest(vcpu, addr, ar, &new_psw, sizeof(new_psw));
564 565
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
566 567
	if (!(new_psw.mask & PSW32_MASK_BASE))
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
568 569 570 571
	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))
572
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
573 574 575 576 577 578
	return 0;
}

static int handle_lpswe(struct kvm_vcpu *vcpu)
{
	psw_t new_psw;
579
	u64 addr;
580
	int rc;
581
	u8 ar;
582

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

586
	addr = kvm_s390_get_base_disp_s(vcpu, &ar);
587 588
	if (addr & 7)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
589
	rc = read_guest(vcpu, addr, ar, &new_psw, sizeof(new_psw));
590 591
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
592 593
	vcpu->arch.sie_block->gpsw = new_psw;
	if (!is_valid_psw(&vcpu->arch.sie_block->gpsw))
594
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
595 596 597
	return 0;
}

598 599
static int handle_stidp(struct kvm_vcpu *vcpu)
{
600
	u64 stidp_data = vcpu->kvm->arch.model.cpuid;
601
	u64 operand2;
602
	int rc;
603
	u8 ar;
604 605

	vcpu->stat.instruction_stidp++;
606

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

610
	operand2 = kvm_s390_get_base_disp_s(vcpu, &ar);
611

612 613
	if (operand2 & 7)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
614

615
	rc = write_guest(vcpu, operand2, ar, &stidp_data, sizeof(stidp_data));
616 617
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
618

619
	VCPU_EVENT(vcpu, 3, "STIDP: store cpu id 0x%llx", stidp_data);
620 621 622 623 624 625 626 627
	return 0;
}

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

628
	cpus = atomic_read(&vcpu->kvm->online_vcpus);
629 630

	/* deal with other level 3 hypervisors */
631
	if (stsi(mem, 3, 2, 2))
632 633 634 635 636 637
		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]));

638
	memset(&mem->vm[0], 0, sizeof(mem->vm[0]));
639 640 641 642 643 644 645 646 647 648 649
	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);
}

650
static void insert_stsi_usr_data(struct kvm_vcpu *vcpu, u64 addr, u8 ar,
651 652 653 654 655 656 657 658 659 660
				 u8 fc, u8 sel1, u16 sel2)
{
	vcpu->run->exit_reason = KVM_EXIT_S390_STSI;
	vcpu->run->s390_stsi.addr = addr;
	vcpu->run->s390_stsi.ar = ar;
	vcpu->run->s390_stsi.fc = fc;
	vcpu->run->s390_stsi.sel1 = sel1;
	vcpu->run->s390_stsi.sel2 = sel2;
}

661 662
static int handle_stsi(struct kvm_vcpu *vcpu)
{
663 664 665
	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;
666
	unsigned long mem = 0;
667
	u64 operand2;
668
	int rc = 0;
669
	u8 ar;
670 671

	vcpu->stat.instruction_stsi++;
672
	VCPU_EVENT(vcpu, 3, "STSI: fc: %u sel1: %u sel2: %u", fc, sel1, sel2);
673

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

677
	if (fc > 3) {
678
		kvm_s390_set_psw_cc(vcpu, 3);
679 680
		return 0;
	}
681

682 683
	if (vcpu->run->s.regs.gprs[0] & 0x0fffff00
	    || vcpu->run->s.regs.gprs[1] & 0xffff0000)
684 685
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);

686
	if (fc == 0) {
687
		vcpu->run->s.regs.gprs[0] = 3 << 28;
688
		kvm_s390_set_psw_cc(vcpu, 0);
689
		return 0;
690 691
	}

692
	operand2 = kvm_s390_get_base_disp_s(vcpu, &ar);
693 694 695 696 697

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

	switch (fc) {
698 699 700 701
	case 1: /* same handling for 1 and 2 */
	case 2:
		mem = get_zeroed_page(GFP_KERNEL);
		if (!mem)
702
			goto out_no_data;
703
		if (stsi((void *) mem, fc, sel1, sel2))
704
			goto out_no_data;
705 706 707
		break;
	case 3:
		if (sel1 != 2 || sel2 != 2)
708
			goto out_no_data;
709 710
		mem = get_zeroed_page(GFP_KERNEL);
		if (!mem)
711
			goto out_no_data;
712 713 714 715
		handle_stsi_3_2_2(vcpu, (void *) mem);
		break;
	}

716
	rc = write_guest(vcpu, operand2, ar, (void *)mem, PAGE_SIZE);
717 718 719
	if (rc) {
		rc = kvm_s390_inject_prog_cond(vcpu, rc);
		goto out;
720
	}
721 722 723 724
	if (vcpu->kvm->arch.user_stsi) {
		insert_stsi_usr_data(vcpu, operand2, ar, fc, sel1, sel2);
		rc = -EREMOTE;
	}
725
	trace_kvm_s390_handle_stsi(vcpu, fc, sel1, sel2, operand2);
726
	free_page(mem);
727
	kvm_s390_set_psw_cc(vcpu, 0);
728
	vcpu->run->s.regs.gprs[0] = 0;
729
	return rc;
730
out_no_data:
731
	kvm_s390_set_psw_cc(vcpu, 3);
732
out:
733
	free_page(mem);
734
	return rc;
735 736
}

737
static const intercept_handler_t b2_handlers[256] = {
738
	[0x02] = handle_stidp,
739
	[0x04] = handle_set_clock,
740 741 742
	[0x10] = handle_set_prefix,
	[0x11] = handle_store_prefix,
	[0x12] = handle_store_cpu_address,
743
	[0x14] = kvm_s390_handle_vsie,
744
	[0x21] = handle_ipte_interlock,
745 746 747
	[0x29] = handle_iske,
	[0x2a] = handle_rrbe,
	[0x2b] = handle_sske,
T
Thomas Huth 已提交
748
	[0x2c] = handle_test_block,
749 750 751 752 753 754 755 756 757 758 759 760 761
	[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,
762
	[0x50] = handle_ipte_interlock,
763
	[0x56] = handle_sthyi,
764 765 766
	[0x5f] = handle_io_inst,
	[0x74] = handle_io_inst,
	[0x76] = handle_io_inst,
767 768
	[0x7d] = handle_stsi,
	[0xb1] = handle_stfl,
769
	[0xb2] = handle_lpswe,
770 771
};

772
int kvm_s390_handle_b2(struct kvm_vcpu *vcpu)
773 774 775
{
	intercept_handler_t handler;

776
	/*
777 778 779 780
	 * 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.
	 */
781
	handler = b2_handlers[vcpu->arch.sie_block->ipa & 0x00ff];
782 783 784
	if (handler)
		return handler(vcpu);

785
	return -EOPNOTSUPP;
786
}
787

788 789 790 791
static int handle_epsw(struct kvm_vcpu *vcpu)
{
	int reg1, reg2;

792
	kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);
793 794

	/* This basically extracts the mask half of the psw. */
795
	vcpu->run->s.regs.gprs[reg1] &= 0xffffffff00000000UL;
796 797
	vcpu->run->s.regs.gprs[reg1] |= vcpu->arch.sie_block->gpsw.mask >> 32;
	if (reg2) {
798
		vcpu->run->s.regs.gprs[reg2] &= 0xffffffff00000000UL;
799
		vcpu->run->s.regs.gprs[reg2] |=
800
			vcpu->arch.sie_block->gpsw.mask & 0x00000000ffffffffUL;
801 802 803 804
	}
	return 0;
}

805 806 807 808 809 810 811 812 813 814 815 816
#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)
{
817
	bool mr = false, mc = false, nq;
818 819
	int reg1, reg2;
	unsigned long start, end;
820
	unsigned char key;
821 822 823 824 825

	vcpu->stat.instruction_pfmf++;

	kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);

826
	if (!test_kvm_facility(vcpu->kvm, 8))
827 828 829
		return kvm_s390_inject_program_int(vcpu, PGM_OPERATION);

	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
830
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
831 832 833 834

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

835 836 837
	/* Only provide non-quiescing support if enabled for the guest */
	if (vcpu->run->s.regs.gprs[reg1] & PFMF_NQ &&
	    !test_kvm_facility(vcpu->kvm, 14))
838 839
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);

840 841 842 843 844 845 846 847 848
	/* Only provide conditional-SSKE support if enabled for the guest */
	if (vcpu->run->s.regs.gprs[reg1] & PFMF_SK &&
	    test_kvm_facility(vcpu->kvm, 10)) {
		mr = vcpu->run->s.regs.gprs[reg1] & PFMF_MR;
		mc = vcpu->run->s.regs.gprs[reg1] & PFMF_MC;
	}

	nq = vcpu->run->s.regs.gprs[reg1] & PFMF_NQ;
	key = vcpu->run->s.regs.gprs[reg1] & PFMF_KEY;
849
	start = vcpu->run->s.regs.gprs[reg2] & PAGE_MASK;
850
	start = kvm_s390_logical_to_effective(vcpu, start);
T
Thomas Huth 已提交
851

852 853 854 855 856
	if (vcpu->run->s.regs.gprs[reg1] & PFMF_CF) {
		if (kvm_s390_check_low_addr_prot_real(vcpu, start))
			return kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm);
	}

857 858
	switch (vcpu->run->s.regs.gprs[reg1] & PFMF_FSC) {
	case 0x00000000:
859 860
		/* only 4k frames specify a real address */
		start = kvm_s390_real_to_abs(vcpu, start);
861 862 863 864 865 866
		end = (start + (1UL << 12)) & ~((1UL << 12) - 1);
		break;
	case 0x00001000:
		end = (start + (1UL << 20)) & ~((1UL << 20) - 1);
		break;
	case 0x00002000:
867 868 869 870 871
		/* only support 2G frame size if EDAT2 is available and we are
		   not in 24-bit addressing mode */
		if (!test_kvm_facility(vcpu->kvm, 78) ||
		    psw_bits(vcpu->arch.sie_block->gpsw).eaba == PSW_AMODE_24BIT)
			return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
872
		end = (start + (1UL << 31)) & ~((1UL << 31) - 1);
873
		break;
874 875 876
	default:
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
	}
877

878
	while (start != end) {
879
		unsigned long useraddr;
T
Thomas Huth 已提交
880 881

		/* Translate guest address to host address */
882
		useraddr = gfn_to_hva(vcpu->kvm, gpa_to_gfn(start));
T
Thomas Huth 已提交
883
		if (kvm_is_error_hva(useraddr))
884 885 886 887 888 889 890 891
			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) {
892 893 894 895
			int rc = __skey_check_enable(vcpu);

			if (rc)
				return rc;
896
			down_read(&current->mm->mmap_sem);
897 898
			rc = cond_set_guest_storage_key(current->mm, useraddr,
							key, NULL, nq, mr, mc);
899
			up_read(&current->mm->mmap_sem);
900
			if (rc < 0)
901 902 903 904 905
				return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
		}

		start += PAGE_SIZE;
	}
906 907 908 909 910 911 912 913 914
	if (vcpu->run->s.regs.gprs[reg1] & PFMF_FSC) {
		if (psw_bits(vcpu->arch.sie_block->gpsw).eaba == PSW_AMODE_64BIT) {
			vcpu->run->s.regs.gprs[reg2] = end;
		} else {
			vcpu->run->s.regs.gprs[reg2] &= ~0xffffffffUL;
			end = kvm_s390_logical_to_effective(vcpu, end);
			vcpu->run->s.regs.gprs[reg2] |= end;
		}
	}
915 916 917
	return 0;
}

918 919 920 921
static int handle_essa(struct kvm_vcpu *vcpu)
{
	/* entries expected to be 1FF */
	int entries = (vcpu->arch.sie_block->cbrlo & ~PAGE_MASK) >> 3;
922
	unsigned long *cbrlo;
923 924 925
	struct gmap *gmap;
	int i;

926
	VCPU_EVENT(vcpu, 4, "ESSA: release %d pages", entries);
927 928
	gmap = vcpu->arch.gmap;
	vcpu->stat.instruction_essa++;
929
	if (!vcpu->kvm->arch.use_cmma)
930 931 932 933 934 935 936 937
		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);

938 939
	/* Retry the ESSA instruction */
	kvm_s390_retry_instr(vcpu);
940 941 942
	vcpu->arch.sie_block->cbrlo &= PAGE_MASK;	/* reset nceo */
	cbrlo = phys_to_virt(vcpu->arch.sie_block->cbrlo);
	down_read(&gmap->mm->mmap_sem);
943 944
	for (i = 0; i < entries; ++i)
		__gmap_zap(gmap, cbrlo[i]);
945 946 947 948
	up_read(&gmap->mm->mmap_sem);
	return 0;
}

949
static const intercept_handler_t b9_handlers[256] = {
950
	[0x8a] = handle_ipte_interlock,
951
	[0x8d] = handle_epsw,
952 953
	[0x8e] = handle_ipte_interlock,
	[0x8f] = handle_ipte_interlock,
954
	[0xab] = handle_essa,
955
	[0xaf] = handle_pfmf,
956 957 958 959 960 961 962 963
};

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];
964 965 966
	if (handler)
		return handler(vcpu);

967 968 969
	return -EOPNOTSUPP;
}

970 971 972 973
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;
974 975
	int reg, rc, nr_regs;
	u32 ctl_array[16];
976
	u64 ga;
977
	u8 ar;
978 979 980 981 982 983

	vcpu->stat.instruction_lctl++;

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

984
	ga = kvm_s390_get_base_disp_rs(vcpu, &ar);
985

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

989
	VCPU_EVENT(vcpu, 4, "LCTL: r1:%d, r3:%d, addr: 0x%llx", reg1, reg3, ga);
990
	trace_kvm_s390_handle_lctl(vcpu, 0, reg1, reg3, ga);
991

992
	nr_regs = ((reg3 - reg1) & 0xf) + 1;
993
	rc = read_guest(vcpu, ga, ar, ctl_array, nr_regs * sizeof(u32));
994 995
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
996
	reg = reg1;
997
	nr_regs = 0;
998 999
	do {
		vcpu->arch.sie_block->gcr[reg] &= 0xffffffff00000000ul;
1000
		vcpu->arch.sie_block->gcr[reg] |= ctl_array[nr_regs++];
1001 1002 1003 1004
		if (reg == reg3)
			break;
		reg = (reg + 1) % 16;
	} while (1);
1005
	kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
1006 1007 1008
	return 0;
}

1009 1010 1011 1012
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;
1013 1014
	int reg, rc, nr_regs;
	u32 ctl_array[16];
1015
	u64 ga;
1016
	u8 ar;
1017 1018 1019 1020 1021 1022

	vcpu->stat.instruction_stctl++;

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

1023
	ga = kvm_s390_get_base_disp_rs(vcpu, &ar);
1024 1025 1026 1027

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

1028
	VCPU_EVENT(vcpu, 4, "STCTL r1:%d, r3:%d, addr: 0x%llx", reg1, reg3, ga);
1029 1030 1031
	trace_kvm_s390_handle_stctl(vcpu, 0, reg1, reg3, ga);

	reg = reg1;
1032
	nr_regs = 0;
1033
	do {
1034
		ctl_array[nr_regs++] = vcpu->arch.sie_block->gcr[reg];
1035 1036 1037 1038
		if (reg == reg3)
			break;
		reg = (reg + 1) % 16;
	} while (1);
1039
	rc = write_guest(vcpu, ga, ar, ctl_array, nr_regs * sizeof(u32));
1040
	return rc ? kvm_s390_inject_prog_cond(vcpu, rc) : 0;
1041 1042
}

1043 1044 1045 1046
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;
1047 1048 1049
	int reg, rc, nr_regs;
	u64 ctl_array[16];
	u64 ga;
1050
	u8 ar;
1051 1052 1053 1054 1055 1056

	vcpu->stat.instruction_lctlg++;

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

1057
	ga = kvm_s390_get_base_disp_rsy(vcpu, &ar);
1058

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

1062
	VCPU_EVENT(vcpu, 4, "LCTLG: r1:%d, r3:%d, addr: 0x%llx", reg1, reg3, ga);
1063
	trace_kvm_s390_handle_lctl(vcpu, 1, reg1, reg3, ga);
1064

1065
	nr_regs = ((reg3 - reg1) & 0xf) + 1;
1066
	rc = read_guest(vcpu, ga, ar, ctl_array, nr_regs * sizeof(u64));
1067 1068 1069 1070
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
	reg = reg1;
	nr_regs = 0;
1071
	do {
1072
		vcpu->arch.sie_block->gcr[reg] = ctl_array[nr_regs++];
1073 1074 1075 1076
		if (reg == reg3)
			break;
		reg = (reg + 1) % 16;
	} while (1);
1077
	kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
1078 1079 1080
	return 0;
}

1081 1082 1083 1084
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;
1085 1086 1087
	int reg, rc, nr_regs;
	u64 ctl_array[16];
	u64 ga;
1088
	u8 ar;
1089 1090 1091 1092 1093 1094

	vcpu->stat.instruction_stctg++;

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

1095
	ga = kvm_s390_get_base_disp_rsy(vcpu, &ar);
1096 1097 1098 1099

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

1100
	VCPU_EVENT(vcpu, 4, "STCTG r1:%d, r3:%d, addr: 0x%llx", reg1, reg3, ga);
1101 1102
	trace_kvm_s390_handle_stctl(vcpu, 1, reg1, reg3, ga);

1103 1104
	reg = reg1;
	nr_regs = 0;
1105
	do {
1106
		ctl_array[nr_regs++] = vcpu->arch.sie_block->gcr[reg];
1107 1108 1109 1110
		if (reg == reg3)
			break;
		reg = (reg + 1) % 16;
	} while (1);
1111
	rc = write_guest(vcpu, ga, ar, ctl_array, nr_regs * sizeof(u64));
1112
	return rc ? kvm_s390_inject_prog_cond(vcpu, rc) : 0;
1113 1114
}

1115
static const intercept_handler_t eb_handlers[256] = {
1116
	[0x2f] = handle_lctlg,
1117
	[0x25] = handle_stctg,
F
Fan Zhang 已提交
1118 1119 1120
	[0x60] = handle_ri,
	[0x61] = handle_ri,
	[0x62] = handle_ri,
1121 1122
};

1123
int kvm_s390_handle_eb(struct kvm_vcpu *vcpu)
1124 1125 1126 1127 1128 1129 1130 1131 1132
{
	intercept_handler_t handler;

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

1133 1134
static int handle_tprot(struct kvm_vcpu *vcpu)
{
1135
	u64 address1, address2;
1136 1137 1138
	unsigned long hva, gpa;
	int ret = 0, cc = 0;
	bool writable;
1139
	u8 ar;
1140 1141 1142

	vcpu->stat.instruction_tprot++;

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

1146
	kvm_s390_get_base_disp_sse(vcpu, &address1, &address2, &ar, NULL);
1147

1148 1149 1150 1151 1152 1153
	/* 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)
1154
		ipte_lock(vcpu);
1155
	ret = guest_translate_address(vcpu, address1, ar, &gpa, GACC_STORE);
1156 1157 1158
	if (ret == PGM_PROTECTION) {
		/* Write protected? Try again with read-only... */
		cc = 1;
1159 1160
		ret = guest_translate_address(vcpu, address1, ar, &gpa,
					      GACC_FETCH);
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
	}
	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;
	}
1172

1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
	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;
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195
}

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

1196 1197 1198 1199 1200
static int handle_sckpf(struct kvm_vcpu *vcpu)
{
	u32 value;

	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
1201
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212

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

1213 1214 1215 1216 1217 1218 1219
static int handle_ptff(struct kvm_vcpu *vcpu)
{
	/* we don't emulate any control instructions yet */
	kvm_s390_set_psw_cc(vcpu, 3);
	return 0;
}

1220
static const intercept_handler_t x01_handlers[256] = {
1221
	[0x04] = handle_ptff,
1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233
	[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;
}