priv.c 37 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
2
/*
3
 * handling privileged instructions
4
 *
5
 * Copyright IBM Corp. 2008, 2018
6
7
8
9
10
11
 *
 *    Author(s): Carsten Otte <cotte@de.ibm.com>
 *               Christian Borntraeger <borntraeger@de.ibm.com>
 */

#include <linux/kvm.h>
12
#include <linux/gfp.h>
13
#include <linux/errno.h>
14
#include <linux/compat.h>
15
16
#include <linux/mm_types.h>

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

Fan Zhang's avatar
Fan Zhang committed
34
35
static int handle_ri(struct kvm_vcpu *vcpu)
{
36
37
	vcpu->stat.instruction_ri++;

Fan Zhang's avatar
Fan Zhang committed
38
	if (test_kvm_facility(vcpu->kvm, 64)) {
39
		VCPU_EVENT(vcpu, 3, "%s", "ENABLE: RI (lazy)");
40
		vcpu->arch.sie_block->ecb3 |= ECB3_RI;
Fan Zhang's avatar
Fan Zhang committed
41
42
43
44
45
46
47
48
49
50
51
52
53
54
		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;
}

55
56
static int handle_gs(struct kvm_vcpu *vcpu)
{
57
58
	vcpu->stat.instruction_gs++;

59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
	if (test_kvm_facility(vcpu->kvm, 133)) {
		VCPU_EVENT(vcpu, 3, "%s", "ENABLE: GS (lazy)");
		preempt_disable();
		__ctl_set_bit(2, 4);
		current->thread.gs_cb = (struct gs_cb *)&vcpu->run->s.regs.gscb;
		restore_gs_cb(current->thread.gs_cb);
		preempt_enable();
		vcpu->arch.sie_block->ecb |= ECB_GS;
		vcpu->arch.sie_block->ecd |= ECD_HOSTREGMGMT;
		vcpu->arch.gs_enabled = 1;
		kvm_s390_retry_instr(vcpu);
		return 0;
	} else
		return kvm_s390_inject_program_int(vcpu, PGM_OPERATION);
}

int kvm_s390_handle_e3(struct kvm_vcpu *vcpu)
{
	int code = vcpu->arch.sie_block->ipb & 0xff;

	if (code == 0x49 || code == 0x4d)
		return handle_gs(vcpu);
	else
		return -EOPNOTSUPP;
}
84
85
86
/* Handle SCK (SET CLOCK) interception */
static int handle_set_clock(struct kvm_vcpu *vcpu)
{
87
	struct kvm_s390_vm_tod_clock gtod = { 0 };
88
	int rc;
89
	u8 ar;
90
	u64 op2;
91

92
93
	vcpu->stat.instruction_sck++;

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

97
	op2 = kvm_s390_get_base_disp_s(vcpu, &ar);
98
99
	if (op2 & 7)	/* Operand must be on a doubleword boundary */
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
100
	rc = read_guest(vcpu, op2, ar, &gtod.tod, sizeof(gtod.tod));
101
102
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
103

104
105
	VCPU_EVENT(vcpu, 3, "SCK: setting guest TOD to 0x%llx", gtod.tod);
	kvm_s390_set_tod_clock(vcpu->kvm, &gtod);
106
107
108
109
110

	kvm_s390_set_psw_cc(vcpu, 0);
	return 0;
}

111
112
113
static int handle_set_prefix(struct kvm_vcpu *vcpu)
{
	u64 operand2;
114
115
	u32 address;
	int rc;
116
	u8 ar;
117
118
119

	vcpu->stat.instruction_spx++;

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

123
	operand2 = kvm_s390_get_base_disp_s(vcpu, &ar);
124
125

	/* must be word boundary */
126
127
	if (operand2 & 3)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
128
129

	/* get the value */
130
	rc = read_guest(vcpu, operand2, ar, &address, sizeof(address));
131
132
133
134
135
136
137
138
139
140
141
	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))
142
		return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
143

144
	kvm_s390_set_prefix(vcpu, address);
145
	trace_kvm_s390_handle_prefix(vcpu, 1, address);
146
147
148
149
150
151
152
	return 0;
}

static int handle_store_prefix(struct kvm_vcpu *vcpu)
{
	u64 operand2;
	u32 address;
153
	int rc;
154
	u8 ar;
155
156

	vcpu->stat.instruction_stpx++;
157

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

161
	operand2 = kvm_s390_get_base_disp_s(vcpu, &ar);
162
163

	/* must be word boundary */
164
165
	if (operand2 & 3)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
166

167
	address = kvm_s390_get_prefix(vcpu);
168
169

	/* get the value */
170
	rc = write_guest(vcpu, operand2, ar, &address, sizeof(address));
171
172
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
173

174
	VCPU_EVENT(vcpu, 3, "STPX: storing prefix 0x%x into 0x%llx", address, operand2);
175
	trace_kvm_s390_handle_prefix(vcpu, 0, address);
176
177
178
179
180
	return 0;
}

static int handle_store_cpu_address(struct kvm_vcpu *vcpu)
{
181
182
183
	u16 vcpu_id = vcpu->vcpu_id;
	u64 ga;
	int rc;
184
	u8 ar;
185
186

	vcpu->stat.instruction_stap++;
187

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

191
	ga = kvm_s390_get_base_disp_s(vcpu, &ar);
192

193
	if (ga & 1)
194
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
195

196
	rc = write_guest(vcpu, ga, ar, &vcpu_id, sizeof(vcpu_id));
197
198
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
199

200
	VCPU_EVENT(vcpu, 3, "STAP: storing cpu address (%u) to 0x%llx", vcpu_id, ga);
201
	trace_kvm_s390_handle_stap(vcpu, ga);
202
203
204
	return 0;
}

205
int kvm_s390_skey_check_enable(struct kvm_vcpu *vcpu)
206
{
207
	int rc;
208
	struct kvm_s390_sie_block *sie_block = vcpu->arch.sie_block;
209
210

	trace_kvm_s390_skey_related_inst(vcpu);
211
212
213
	/* Already enabled? */
	if (vcpu->kvm->arch.use_skf &&
	    !(sie_block->ictl & (ICTL_ISKE | ICTL_SSKE | ICTL_RRBE)) &&
214
	    !kvm_s390_test_cpuflags(vcpu, CPUSTAT_KSS))
215
		return 0;
216

217
	rc = s390_enable_skey();
218
	VCPU_EVENT(vcpu, 3, "enabling storage keys for guest: %d", rc);
219
220
221
222
223
224
225
226
227
228
	if (rc)
		return rc;

	if (kvm_s390_test_cpuflags(vcpu, CPUSTAT_KSS))
		kvm_s390_clear_cpuflags(vcpu, CPUSTAT_KSS);
	if (!vcpu->kvm->arch.use_skf)
		sie_block->ictl |= ICTL_ISKE | ICTL_SSKE | ICTL_RRBE;
	else
		sie_block->ictl &= ~(ICTL_ISKE | ICTL_SSKE | ICTL_RRBE);
	return 0;
229
230
}

231
static int try_handle_skey(struct kvm_vcpu *vcpu)
232
{
233
	int rc;
234

235
	rc = kvm_s390_skey_check_enable(vcpu);
236
237
	if (rc)
		return rc;
238
	if (vcpu->kvm->arch.use_skf) {
239
240
241
242
243
244
245
		/* 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;
	}
	return 0;
}
246

247
248
249
250
251
252
253
static int handle_iske(struct kvm_vcpu *vcpu)
{
	unsigned long addr;
	unsigned char key;
	int reg1, reg2;
	int rc;

254
255
	vcpu->stat.instruction_iske++;

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

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

288
289
	vcpu->stat.instruction_rrbe++;

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

293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
	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;

328
329
	vcpu->stat.instruction_sske++;

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

333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
	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 */
351
		end = (start + _SEGMENT_SIZE) & ~(_SEGMENT_SIZE - 1);
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
	} 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;
371
	}
372
373
374
375
376
377
378
379
380
381
382
383

	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) {
Heiko Carstens's avatar
Heiko Carstens committed
384
		if (psw_bits(vcpu->arch.sie_block->gpsw).eaba == PSW_BITS_AMODE_64BIT)
385
386
387
388
389
390
			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;
	}
391
392
393
	return 0;
}

394
395
396
static int handle_ipte_interlock(struct kvm_vcpu *vcpu)
{
	vcpu->stat.instruction_ipte_interlock++;
397
	if (psw_bits(vcpu->arch.sie_block->gpsw).pstate)
398
399
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
	wait_event(vcpu->kvm->arch.ipte_wq, !ipte_lock_held(vcpu));
400
	kvm_s390_retry_instr(vcpu);
401
402
403
404
	VCPU_EVENT(vcpu, 4, "%s", "retrying ipte interlock operation");
	return 0;
}

Thomas Huth's avatar
Thomas Huth committed
405
406
407
408
409
static int handle_test_block(struct kvm_vcpu *vcpu)
{
	gpa_t addr;
	int reg2;

410
411
	vcpu->stat.instruction_tb++;

Thomas Huth's avatar
Thomas Huth committed
412
413
414
415
416
	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;
417
	addr = kvm_s390_logical_to_effective(vcpu, addr);
418
	if (kvm_s390_check_low_addr_prot_real(vcpu, addr))
419
		return kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm);
Thomas Huth's avatar
Thomas Huth committed
420
421
	addr = kvm_s390_real_to_abs(vcpu, addr);

422
	if (kvm_is_error_gpa(vcpu->kvm, addr))
Thomas Huth's avatar
Thomas Huth committed
423
424
425
426
427
		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.
	 */
428
	if (kvm_clear_guest(vcpu->kvm, addr, PAGE_SIZE))
Thomas Huth's avatar
Thomas Huth committed
429
430
431
432
433
434
		return -EFAULT;
	kvm_s390_set_psw_cc(vcpu, 0);
	vcpu->run->s.regs.gprs[0] = 0;
	return 0;
}

435
static int handle_tpi(struct kvm_vcpu *vcpu)
436
{
437
	struct kvm_s390_interrupt_info *inti;
438
439
	unsigned long len;
	u32 tpi_data[3];
440
	int rc;
441
	u64 addr;
442
	u8 ar;
443

444
445
	vcpu->stat.instruction_tpi++;

446
	addr = kvm_s390_get_base_disp_s(vcpu, &ar);
447
448
	if (addr & 3)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
449

450
	inti = kvm_s390_get_io_int(vcpu->kvm, vcpu->arch.sie_block->gcr[6], 0);
451
452
453
454
455
	if (!inti) {
		kvm_s390_set_psw_cc(vcpu, 0);
		return 0;
	}

456
457
458
	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;
459
460
461
462
463
	if (addr) {
		/*
		 * Store the two-word I/O interruption code into the
		 * provided area.
		 */
464
		len = sizeof(tpi_data) - 4;
465
		rc = write_guest(vcpu, addr, ar, &tpi_data, len);
466
467
468
469
		if (rc) {
			rc = kvm_s390_inject_prog_cond(vcpu, rc);
			goto reinject_interrupt;
		}
470
471
472
473
474
	} else {
		/*
		 * Store the three-word I/O interruption code into
		 * the appropriate lowcore area.
		 */
475
		len = sizeof(tpi_data);
476
477
		if (write_guest_lc(vcpu, __LC_SUBCHANNEL_ID, &tpi_data, len)) {
			/* failed writes to the low core are not recoverable */
478
			rc = -EFAULT;
479
480
			goto reinject_interrupt;
		}
481
	}
482
483
484
485
486
487

	/* irq was successfully handed to the guest */
	kfree(inti);
	kvm_s390_set_psw_cc(vcpu, 1);
	return 0;
reinject_interrupt:
488
489
490
491
492
	/*
	 * If we encounter a problem storing the interruption code, the
	 * instruction is suppressed from the guest's view: reinject the
	 * interrupt.
	 */
493
494
495
496
	if (kvm_s390_reinject_io_int(vcpu->kvm, inti)) {
		kfree(inti);
		rc = -EFAULT;
	}
497
	/* don't set the cc, a pgm irq was injected or we drop to user space */
498
	return rc ? -EFAULT : 0;
499
500
}

501
502
static int handle_tsch(struct kvm_vcpu *vcpu)
{
503
504
	struct kvm_s390_interrupt_info *inti = NULL;
	const u64 isc_mask = 0xffUL << 24; /* all iscs set */
505

506
507
	vcpu->stat.instruction_tsch++;

508
509
510
511
	/* 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]);
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537

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

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

541
542
543
544
545
546
547
548
549
550
	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. */
551
		vcpu->stat.instruction_io_other++;
552
553
554
		return -EOPNOTSUPP;
	} else {
		/*
555
		 * Set condition code 3 to stop the guest from issuing channel
556
557
		 * I/O instructions.
		 */
558
		kvm_s390_set_psw_cc(vcpu, 3);
559
560
561
562
		return 0;
	}
}

563
564
565
static int handle_stfl(struct kvm_vcpu *vcpu)
{
	int rc;
566
	unsigned int fac;
567
568

	vcpu->stat.instruction_stfl++;
569
570
571
572

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

573
574
575
576
	/*
	 * 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.
	 */
577
	fac = *vcpu->kvm->arch.model.fac_list >> 32;
578
	rc = write_guest_lc(vcpu, offsetof(struct lowcore, stfl_fac_list),
579
			    &fac, sizeof(fac));
580
	if (rc)
581
		return rc;
582
	VCPU_EVENT(vcpu, 3, "STFL: store facility list 0x%x", fac);
583
	trace_kvm_s390_handle_stfl(vcpu, fac);
584
585
586
	return 0;
}

587
588
#define PSW_MASK_ADDR_MODE (PSW_MASK_EA | PSW_MASK_BA)
#define PSW_MASK_UNASSIGNED 0xb80800fe7fffffffUL
589
#define PSW_ADDR_24 0x0000000000ffffffUL
590
591
#define PSW_ADDR_31 0x000000007fffffffUL

592
593
int is_valid_psw(psw_t *psw)
{
594
595
596
597
598
599
600
601
602
603
	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;
604
605
	if (psw->addr & 1)
		return 0;
606
607
608
	return 1;
}

609
610
int kvm_s390_handle_lpsw(struct kvm_vcpu *vcpu)
{
611
	psw_t *gpsw = &vcpu->arch.sie_block->gpsw;
612
	psw_compat_t new_psw;
613
	u64 addr;
614
	int rc;
615
	u8 ar;
616

617
618
	vcpu->stat.instruction_lpsw++;

619
	if (gpsw->mask & PSW_MASK_PSTATE)
620
621
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);

622
	addr = kvm_s390_get_base_disp_s(vcpu, &ar);
623
624
	if (addr & 7)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
625

626
	rc = read_guest(vcpu, addr, ar, &new_psw, sizeof(new_psw));
627
628
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
629
630
	if (!(new_psw.mask & PSW32_MASK_BASE))
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
631
632
633
634
	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))
635
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
636
637
638
639
640
641
	return 0;
}

static int handle_lpswe(struct kvm_vcpu *vcpu)
{
	psw_t new_psw;
642
	u64 addr;
643
	int rc;
644
	u8 ar;
645

646
647
	vcpu->stat.instruction_lpswe++;

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

651
	addr = kvm_s390_get_base_disp_s(vcpu, &ar);
652
653
	if (addr & 7)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
654
	rc = read_guest(vcpu, addr, ar, &new_psw, sizeof(new_psw));
655
656
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
657
658
	vcpu->arch.sie_block->gpsw = new_psw;
	if (!is_valid_psw(&vcpu->arch.sie_block->gpsw))
659
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
660
661
662
	return 0;
}

663
664
static int handle_stidp(struct kvm_vcpu *vcpu)
{
665
	u64 stidp_data = vcpu->kvm->arch.model.cpuid;
666
	u64 operand2;
667
	int rc;
668
	u8 ar;
669
670

	vcpu->stat.instruction_stidp++;
671

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

675
	operand2 = kvm_s390_get_base_disp_s(vcpu, &ar);
676

677
678
	if (operand2 & 7)
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
679

680
	rc = write_guest(vcpu, operand2, ar, &stidp_data, sizeof(stidp_data));
681
682
	if (rc)
		return kvm_s390_inject_prog_cond(vcpu, rc);
683

684
	VCPU_EVENT(vcpu, 3, "STIDP: store cpu id 0x%llx", stidp_data);
685
686
687
688
689
690
691
692
	return 0;
}

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

693
	cpus = atomic_read(&vcpu->kvm->online_vcpus);
694
695

	/* deal with other level 3 hypervisors */
696
	if (stsi(mem, 3, 2, 2))
697
698
699
700
701
702
		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]));

703
	memset(&mem->vm[0], 0, sizeof(mem->vm[0]));
704
705
706
707
708
709
710
711
712
713
714
	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);
}

715
static void insert_stsi_usr_data(struct kvm_vcpu *vcpu, u64 addr, u8 ar,
716
717
718
719
720
721
722
723
724
725
				 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;
}

726
727
static int handle_stsi(struct kvm_vcpu *vcpu)
{
728
729
730
	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;
731
	unsigned long mem = 0;
732
	u64 operand2;
733
	int rc = 0;
734
	u8 ar;
735
736

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

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

742
	if (fc > 3) {
743
		kvm_s390_set_psw_cc(vcpu, 3);
744
745
		return 0;
	}
746

747
748
	if (vcpu->run->s.regs.gprs[0] & 0x0fffff00
	    || vcpu->run->s.regs.gprs[1] & 0xffff0000)
749
750
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);

751
	if (fc == 0) {
752
		vcpu->run->s.regs.gprs[0] = 3 << 28;
753
		kvm_s390_set_psw_cc(vcpu, 0);
754
		return 0;
755
756
	}

757
	operand2 = kvm_s390_get_base_disp_s(vcpu, &ar);
758
759
760
761
762

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

	switch (fc) {
763
764
765
766
	case 1: /* same handling for 1 and 2 */
	case 2:
		mem = get_zeroed_page(GFP_KERNEL);
		if (!mem)
767
			goto out_no_data;
768
		if (stsi((void *) mem, fc, sel1, sel2))
769
			goto out_no_data;
770
771
772
		break;
	case 3:
		if (sel1 != 2 || sel2 != 2)
773
			goto out_no_data;
774
775
		mem = get_zeroed_page(GFP_KERNEL);
		if (!mem)
776
			goto out_no_data;
777
778
779
780
		handle_stsi_3_2_2(vcpu, (void *) mem);
		break;
	}

781
	rc = write_guest(vcpu, operand2, ar, (void *)mem, PAGE_SIZE);
782
783
784
	if (rc) {
		rc = kvm_s390_inject_prog_cond(vcpu, rc);
		goto out;
785
	}
786
787
788
789
	if (vcpu->kvm->arch.user_stsi) {
		insert_stsi_usr_data(vcpu, operand2, ar, fc, sel1, sel2);
		rc = -EREMOTE;
	}
790
	trace_kvm_s390_handle_stsi(vcpu, fc, sel1, sel2, operand2);
791
	free_page(mem);
792
	kvm_s390_set_psw_cc(vcpu, 0);
793
	vcpu->run->s.regs.gprs[0] = 0;
794
	return rc;
795
out_no_data:
796
	kvm_s390_set_psw_cc(vcpu, 3);
797
out:
798
	free_page(mem);
799
	return rc;
800
801
}

802
int kvm_s390_handle_b2(struct kvm_vcpu *vcpu)
803
{
804
805
806
807
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
844
845
846
847
848
849
850
851
852
853
854
855
	switch (vcpu->arch.sie_block->ipa & 0x00ff) {
	case 0x02:
		return handle_stidp(vcpu);
	case 0x04:
		return handle_set_clock(vcpu);
	case 0x10:
		return handle_set_prefix(vcpu);
	case 0x11:
		return handle_store_prefix(vcpu);
	case 0x12:
		return handle_store_cpu_address(vcpu);
	case 0x14:
		return kvm_s390_handle_vsie(vcpu);
	case 0x21:
	case 0x50:
		return handle_ipte_interlock(vcpu);
	case 0x29:
		return handle_iske(vcpu);
	case 0x2a:
		return handle_rrbe(vcpu);
	case 0x2b:
		return handle_sske(vcpu);
	case 0x2c:
		return handle_test_block(vcpu);
	case 0x30:
	case 0x31:
	case 0x32:
	case 0x33:
	case 0x34:
	case 0x35:
	case 0x36:
	case 0x37:
	case 0x38:
	case 0x39:
	case 0x3a:
	case 0x3b:
	case 0x3c:
	case 0x5f:
	case 0x74:
	case 0x76:
		return handle_io_inst(vcpu);
	case 0x56:
		return handle_sthyi(vcpu);
	case 0x7d:
		return handle_stsi(vcpu);
	case 0xb1:
		return handle_stfl(vcpu);
	case 0xb2:
		return handle_lpswe(vcpu);
	default:
		return -EOPNOTSUPP;
	}
856
}
857

858
859
860
861
static int handle_epsw(struct kvm_vcpu *vcpu)
{
	int reg1, reg2;

862
863
	vcpu->stat.instruction_epsw++;

864
	kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);
865
866

	/* This basically extracts the mask half of the psw. */
867
	vcpu->run->s.regs.gprs[reg1] &= 0xffffffff00000000UL;
868
869
	vcpu->run->s.regs.gprs[reg1] |= vcpu->arch.sie_block->gpsw.mask >> 32;
	if (reg2) {
870
		vcpu->run->s.regs.gprs[reg2] &= 0xffffffff00000000UL;
871
		vcpu->run->s.regs.gprs[reg2] |=
872
			vcpu->arch.sie_block->gpsw.mask & 0x00000000ffffffffUL;
873
874
875
876
	}
	return 0;
}

877
878
879
880
881
882
883
884
885
886
887
888
#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)
{
889
	bool mr = false, mc = false, nq;
890
891
	int reg1, reg2;
	unsigned long start, end;
892
	unsigned char key;
893
894
895
896
897

	vcpu->stat.instruction_pfmf++;

	kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);

898
	if (!test_kvm_facility(vcpu->kvm, 8))
899
900
901
		return kvm_s390_inject_program_int(vcpu, PGM_OPERATION);

	if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
902
		return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
903
904
905
906

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

907
908
909
	/* 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))
910
911
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);

912
913
914
915
916
917
918
919
920
	/* 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;
921
	start = vcpu->run->s.regs.gprs[reg2] & PAGE_MASK;
922
	start = kvm_s390_logical_to_effective(vcpu, start);
Thomas Huth's avatar
Thomas Huth committed
923

924
925
926
927
928
	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);
	}

929
930
	switch (vcpu->run->s.regs.gprs[reg1] & PFMF_FSC) {
	case 0x00000000:
931
932
		/* only 4k frames specify a real address */
		start = kvm_s390_real_to_abs(vcpu, start);
933
		end = (start + PAGE_SIZE) & ~(PAGE_SIZE - 1);
934
935
		break;
	case 0x00001000:
936
		end = (start + _SEGMENT_SIZE) & ~(_SEGMENT_SIZE - 1);
937
938
		break;
	case 0x00002000:
939
940
941
		/* 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) ||
Heiko Carstens's avatar
Heiko Carstens committed
942
		    psw_bits(vcpu->arch.sie_block->gpsw).eaba == PSW_BITS_AMODE_24BIT)
943
			return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
944
		end = (start + _REGION3_SIZE) & ~(_REGION3_SIZE - 1);
945
		break;
946
947
948
	default:
		return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
	}
949

950
	while (start != end) {
951
		unsigned long useraddr;
Thomas Huth's avatar
Thomas Huth committed
952
953

		/* Translate guest address to host address */
954
		useraddr = gfn_to_hva(vcpu->kvm, gpa_to_gfn(start));
Thomas Huth's avatar
Thomas Huth committed
955
		if (kvm_is_error_hva(useraddr))
956
957
958
			return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);

		if (vcpu->run->s.regs.gprs[reg1] & PFMF_CF) {
959
			if (kvm_clear_guest(vcpu->kvm, start, PAGE_SIZE))
960
961
962
963
				return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
		}

		if (vcpu->run->s.regs.gprs[reg1] & PFMF_SK) {
964
			int rc = kvm_s390_skey_check_enable(vcpu);
965
966
967

			if (rc)
				return rc;
968
			down_read(&current->mm->mmap_sem);
969
970
			rc = cond_set_guest_storage_key(current->mm, useraddr,
							key, NULL, nq, mr, mc);
971
			up_read(&current->mm->mmap_sem);
972
			if (rc < 0)
973
974
975
976
977
				return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
		}

		start += PAGE_SIZE;
	}
978
	if (vcpu->run->s.regs.gprs[reg1] & PFMF_FSC) {
Heiko Carstens's avatar
Heiko Carstens committed
979
		if (psw_bits(vcpu->arch.sie_block->gpsw).eaba == PSW_BITS_AMODE_64BIT) {
980
981
982
983
984
985
986
			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;
		}
	}
987
988
989
	return 0;
}

990
991
992
993
/*
 * Must be called with relevant read locks held (kvm->mm->mmap_sem, kvm->srcu)
 */
static inline int __do_essa(struct kvm_vcpu *vcpu, const int orc)
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
{
	int r1, r2, nappended, entries;
	unsigned long gfn, hva, res, pgstev, ptev;
	unsigned long *cbrlo;

	/*
	 * We don't need to set SD.FPF.SK to 1 here, because if we have a
	 * machine check here we either handle it or crash
	 */

	kvm_s390_get_regs_rre(vcpu, &r1, &r2);
	gfn = vcpu->run->s.regs.gprs[r2] >> PAGE_SHIFT;
	hva = gfn_to_hva(vcpu->kvm, gfn);
	entries = (vcpu->arch.sie_block->cbrlo & ~PAGE_MASK) >> 3;

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

	nappended = pgste_perform_essa(vcpu->kvm->mm, hva, orc, &ptev, &pgstev);
	if (nappended < 0) {
		res = orc ? 0x10 : 0;
		vcpu->run->s.regs.gprs[r1] = res; /* Exception Indication */
		return 0;
	}
	res = (pgstev & _PGSTE_GPS_USAGE_MASK) >> 22;
	/*
	 * Set the block-content state part of the result. 0 means resident, so
	 * nothing to do if the page is valid. 2 is for preserved pages
	 * (non-present and non-zero), and 3 for zero pages (non-present and
	 * zero).
	 */
	if (ptev & _PAGE_INVALID) {
		res |= 2;
		if (pgstev & _PGSTE_GPS_ZERO)
			res |= 1;
	}
1030
1031
	if (pgstev & _PGSTE_GPS_NODAT)
		res |= 0x20;
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
	vcpu->run->s.regs.gprs[r1] = res;
	/*
	 * It is possible that all the normal 511 slots were full, in which case
	 * we will now write in the 512th slot, which is reserved for host use.
	 * In both cases we let the normal essa handling code process all the
	 * slots, including the reserved one, if needed.
	 */
	if (nappended > 0) {
		cbrlo = phys_to_virt(vcpu->arch.sie_block->cbrlo & PAGE_MASK);
		cbrlo[entries] = gfn << PAGE_SHIFT;
	}

1044
1045
1046
1047
1048
1049
	if (orc) {
		struct kvm_memory_slot *ms = gfn_to_memslot(vcpu->kvm, gfn);

		/* Increment only if we are really flipping the bit */
		if (ms && !test_and_set_bit(gfn - ms->base_gfn, kvm_second_dirty_bitmap(ms)))
			atomic64_inc(&vcpu->kvm->arch.cmma_dirty_pages);
1050
1051
1052
1053
1054
	}

	return nappended;
}

1055
1056
1057
1058
static int handle_essa(struct kvm_vcpu *vcpu)
{
	/* entries expected to be 1FF */
	int entries = (vcpu->arch.sie_block->cbrlo & ~PAGE_MASK) >> 3;
1059
	unsigned long *cbrlo;
1060
	struct gmap *gmap;
1061
	int i, orc;
1062

1063
	VCPU_EVENT(vcpu, 4, "ESSA: release %d pages", entries);
1064
1065
	gmap = vcpu->arch.gmap;
	vcpu->stat.instruction_essa++;
1066
	if (!vcpu->kvm->arch.use_cmma)
1067
1068
1069
1070
		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);
1071
1072
	/* Check for invalid operation request code */
	orc = (vcpu->arch.sie_block->ipb & 0xf0000000) >> 28;
1073
1074
1075
	/* ORCs 0-6 are always valid */
	if (orc > (test_kvm_facility(vcpu->kvm, 147) ? ESSA_SET_STABLE_NODAT
						: ESSA_SET_STABLE_IF_RESIDENT))