kvm-s390.h 11.8 KB
Newer Older
1
/*
2
 * definition for kvm on s390
3
 *
4
 * Copyright IBM Corp. 2008, 2009
5 6 7 8 9 10 11
 *
 * 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>
12
 *               Christian Ehrhardt <ehrhardt@de.ibm.com>
13 14 15 16
 */

#ifndef ARCH_S390_KVM_S390_H
#define ARCH_S390_KVM_S390_H
17

18
#include <linux/hrtimer.h>
19
#include <linux/kvm.h>
20
#include <linux/kvm_host.h>
21
#include <asm/facility.h>
22
#include <asm/processor.h>
23 24 25

typedef int (*intercept_handler_t)(struct kvm_vcpu *vcpu);

26 27 28 29 30
/* Transactional Memory Execution related macros */
#define IS_TE_ENABLED(vcpu)	((vcpu->arch.sie_block->ecb & 0x10))
#define TDB_FORMAT1		1
#define IS_ITDB_VALID(vcpu)	((*(char *)vcpu->arch.sie_block->itdba == TDB_FORMAT1))

31 32 33 34 35 36 37
extern debug_info_t *kvm_s390_dbf;
#define KVM_EVENT(d_loglevel, d_string, d_args...)\
do { \
	debug_sprintf_event(kvm_s390_dbf, d_loglevel, d_string "\n", \
	  d_args); \
} while (0)

38 39 40 41 42 43 44 45 46 47 48 49 50
#define VM_EVENT(d_kvm, d_loglevel, d_string, d_args...)\
do { \
	debug_sprintf_event(d_kvm->arch.dbf, d_loglevel, d_string "\n", \
	  d_args); \
} while (0)

#define VCPU_EVENT(d_vcpu, d_loglevel, d_string, d_args...)\
do { \
	debug_sprintf_event(d_vcpu->kvm->arch.dbf, d_loglevel, \
	  "%02d[%016lx-%016lx]: " d_string "\n", d_vcpu->vcpu_id, \
	  d_vcpu->arch.sie_block->gpsw.mask, d_vcpu->arch.sie_block->gpsw.addr,\
	  d_args); \
} while (0)
51

52
static inline int is_vcpu_stopped(struct kvm_vcpu *vcpu)
53
{
54
	return atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED;
55 56
}

57 58 59 60 61
static inline int is_vcpu_idle(struct kvm_vcpu *vcpu)
{
	return atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_WAIT;
}

62 63 64 65 66 67 68 69 70 71
static inline int kvm_is_ucontrol(struct kvm *kvm)
{
#ifdef CONFIG_KVM_S390_UCONTROL
	if (kvm->arch.gmap)
		return 0;
	return 1;
#else
	return 0;
#endif
}
72

73 74 75 76 77 78
#define GUEST_PREFIX_SHIFT 13
static inline u32 kvm_s390_get_prefix(struct kvm_vcpu *vcpu)
{
	return vcpu->arch.sie_block->prefix << GUEST_PREFIX_SHIFT;
}

79 80
static inline void kvm_s390_set_prefix(struct kvm_vcpu *vcpu, u32 prefix)
{
81 82
	VCPU_EVENT(vcpu, 3, "set prefix of cpu %03u to 0x%x", vcpu->vcpu_id,
		   prefix);
83
	vcpu->arch.sie_block->prefix = prefix >> GUEST_PREFIX_SHIFT;
84
	kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
85
	kvm_make_request(KVM_REQ_MMU_RELOAD, vcpu);
86 87
}

88 89 90
typedef u8 __bitwise ar_t;

static inline u64 kvm_s390_get_base_disp_s(struct kvm_vcpu *vcpu, ar_t *ar)
91
{
92 93
	u32 base2 = vcpu->arch.sie_block->ipb >> 28;
	u32 disp2 = ((vcpu->arch.sie_block->ipb & 0x0fff0000) >> 16);
94

95 96 97
	if (ar)
		*ar = base2;

98 99 100 101
	return (base2 ? vcpu->run->s.regs.gprs[base2] : 0) + disp2;
}

static inline void kvm_s390_get_base_disp_sse(struct kvm_vcpu *vcpu,
102 103
					      u64 *address1, u64 *address2,
					      ar_t *ar_b1, ar_t *ar_b2)
104
{
105 106 107 108
	u32 base1 = (vcpu->arch.sie_block->ipb & 0xf0000000) >> 28;
	u32 disp1 = (vcpu->arch.sie_block->ipb & 0x0fff0000) >> 16;
	u32 base2 = (vcpu->arch.sie_block->ipb & 0xf000) >> 12;
	u32 disp2 = vcpu->arch.sie_block->ipb & 0x0fff;
109 110 111

	*address1 = (base1 ? vcpu->run->s.regs.gprs[base1] : 0) + disp1;
	*address2 = (base2 ? vcpu->run->s.regs.gprs[base2] : 0) + disp2;
112 113 114 115 116

	if (ar_b1)
		*ar_b1 = base1;
	if (ar_b2)
		*ar_b2 = base2;
117 118
}

119 120
static inline void kvm_s390_get_regs_rre(struct kvm_vcpu *vcpu, int *r1, int *r2)
{
121 122 123 124
	if (r1)
		*r1 = (vcpu->arch.sie_block->ipb & 0x00f00000) >> 20;
	if (r2)
		*r2 = (vcpu->arch.sie_block->ipb & 0x000f0000) >> 16;
125 126
}

127
static inline u64 kvm_s390_get_base_disp_rsy(struct kvm_vcpu *vcpu, ar_t *ar)
128
{
129 130
	u32 base2 = vcpu->arch.sie_block->ipb >> 28;
	u32 disp2 = ((vcpu->arch.sie_block->ipb & 0x0fff0000) >> 16) +
131
			((vcpu->arch.sie_block->ipb & 0xff00) << 4);
132 133 134
	/* The displacement is a 20bit _SIGNED_ value */
	if (disp2 & 0x80000)
		disp2+=0xfff00000;
135

136 137 138
	if (ar)
		*ar = base2;

139
	return (base2 ? vcpu->run->s.regs.gprs[base2] : 0) + (long)(int)disp2;
140 141
}

142
static inline u64 kvm_s390_get_base_disp_rs(struct kvm_vcpu *vcpu, ar_t *ar)
143
{
144 145
	u32 base2 = vcpu->arch.sie_block->ipb >> 28;
	u32 disp2 = ((vcpu->arch.sie_block->ipb & 0x0fff0000) >> 16);
146

147 148 149
	if (ar)
		*ar = base2;

150 151 152
	return (base2 ? vcpu->run->s.regs.gprs[base2] : 0) + disp2;
}

153 154 155 156 157 158 159
/* Set the condition code in the guest program status word */
static inline void kvm_s390_set_psw_cc(struct kvm_vcpu *vcpu, unsigned long cc)
{
	vcpu->arch.sie_block->gpsw.mask &= ~(3UL << 44);
	vcpu->arch.sie_block->gpsw.mask |= cc << 44;
}

160
/* test availability of facility in a kvm instance */
161 162
static inline int test_kvm_facility(struct kvm *kvm, unsigned long nr)
{
163 164
	return __test_facility(nr, kvm->arch.model.fac_mask) &&
		__test_facility(nr, kvm->arch.model.fac_list);
165 166
}

167 168 169 170 171 172 173 174 175 176 177
static inline int set_kvm_facility(u64 *fac_list, unsigned long nr)
{
	unsigned char *ptr;

	if (nr >= MAX_FACILITY_BIT)
		return -EINVAL;
	ptr = (unsigned char *) fac_list + (nr >> 3);
	*ptr |= (0x80UL >> (nr & 7));
	return 0;
}

178 179 180 181 182 183
static inline int test_kvm_cpu_feat(struct kvm *kvm, unsigned long nr)
{
	WARN_ON_ONCE(nr >= KVM_S390_VM_CPU_FEAT_NR_BITS);
	return test_bit_inv(nr, kvm->arch.cpu_feat);
}

184 185 186 187 188 189
/* are cpu states controlled by user space */
static inline int kvm_s390_user_cpu_state_ctrl(struct kvm *kvm)
{
	return kvm->arch.user_cpu_state_ctrl != 0;
}

190
/* implemented in interrupt.c */
191
int kvm_s390_handle_wait(struct kvm_vcpu *vcpu);
192
void kvm_s390_vcpu_wakeup(struct kvm_vcpu *vcpu);
193
enum hrtimer_restart kvm_s390_idle_wakeup(struct hrtimer *timer);
194
int __must_check kvm_s390_deliver_pending_interrupts(struct kvm_vcpu *vcpu);
195
void kvm_s390_clear_local_irqs(struct kvm_vcpu *vcpu);
196
void kvm_s390_clear_float_irqs(struct kvm *kvm);
197 198 199
int __must_check kvm_s390_inject_vm(struct kvm *kvm,
				    struct kvm_s390_interrupt *s390int);
int __must_check kvm_s390_inject_vcpu(struct kvm_vcpu *vcpu,
200
				      struct kvm_s390_irq *irq);
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
static inline int kvm_s390_inject_prog_irq(struct kvm_vcpu *vcpu,
					   struct kvm_s390_pgm_info *pgm_info)
{
	struct kvm_s390_irq irq = {
		.type = KVM_S390_PROGRAM_INT,
		.u.pgm = *pgm_info,
	};

	return kvm_s390_inject_vcpu(vcpu, &irq);
}
static inline int kvm_s390_inject_program_int(struct kvm_vcpu *vcpu, u16 code)
{
	struct kvm_s390_irq irq = {
		.type = KVM_S390_PROGRAM_INT,
		.u.pgm.code = code,
	};

	return kvm_s390_inject_vcpu(vcpu, &irq);
}
220
struct kvm_s390_interrupt_info *kvm_s390_get_io_int(struct kvm *kvm,
221
						    u64 isc_mask, u32 schid);
222 223
int kvm_s390_reinject_io_int(struct kvm *kvm,
			     struct kvm_s390_interrupt_info *inti);
224
int kvm_s390_mask_adapter(struct kvm *kvm, unsigned int id, bool masked);
225

226
/* implemented in intercept.c */
227
u8 kvm_s390_get_ilen(struct kvm_vcpu *vcpu);
228
int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu);
229 230 231 232 233 234 235 236 237 238 239 240 241 242
static inline void kvm_s390_rewind_psw(struct kvm_vcpu *vcpu, int ilen)
{
	struct kvm_s390_sie_block *sie_block = vcpu->arch.sie_block;

	sie_block->gpsw.addr = __rewind_psw(sie_block->gpsw, ilen);
}
static inline void kvm_s390_forward_psw(struct kvm_vcpu *vcpu, int ilen)
{
	kvm_s390_rewind_psw(vcpu, -ilen);
}
static inline void kvm_s390_retry_instr(struct kvm_vcpu *vcpu)
{
	kvm_s390_rewind_psw(vcpu, kvm_s390_get_ilen(vcpu));
}
243

244
/* implemented in priv.c */
T
Thomas Huth 已提交
245
int is_valid_psw(psw_t *psw);
246
int kvm_s390_handle_b2(struct kvm_vcpu *vcpu);
247
int kvm_s390_handle_e5(struct kvm_vcpu *vcpu);
248
int kvm_s390_handle_01(struct kvm_vcpu *vcpu);
249 250
int kvm_s390_handle_b9(struct kvm_vcpu *vcpu);
int kvm_s390_handle_lpsw(struct kvm_vcpu *vcpu);
251
int kvm_s390_handle_stctl(struct kvm_vcpu *vcpu);
252 253
int kvm_s390_handle_lctl(struct kvm_vcpu *vcpu);
int kvm_s390_handle_eb(struct kvm_vcpu *vcpu);
254 255 256

/* implemented in sigp.c */
int kvm_s390_handle_sigp(struct kvm_vcpu *vcpu);
257
int kvm_s390_handle_sigp_pei(struct kvm_vcpu *vcpu);
258

J
Janosch Frank 已提交
259 260 261
/* implemented in sthyi.c */
int handle_sthyi(struct kvm_vcpu *vcpu);

262
/* implemented in kvm-s390.c */
263
void kvm_s390_set_tod_clock(struct kvm *kvm, u64 tod);
264
long kvm_arch_fault_in_page(struct kvm_vcpu *vcpu, gpa_t gpa, int writable);
265
int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long addr);
E
Eric Farman 已提交
266 267
int kvm_s390_store_adtl_status_unloaded(struct kvm_vcpu *vcpu,
					unsigned long addr);
268
int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr);
E
Eric Farman 已提交
269
int kvm_s390_vcpu_store_adtl_status(struct kvm_vcpu *vcpu, unsigned long addr);
270 271
void kvm_s390_vcpu_start(struct kvm_vcpu *vcpu);
void kvm_s390_vcpu_stop(struct kvm_vcpu *vcpu);
272 273
void kvm_s390_vcpu_block(struct kvm_vcpu *vcpu);
void kvm_s390_vcpu_unblock(struct kvm_vcpu *vcpu);
274
void exit_sie(struct kvm_vcpu *vcpu);
275
void kvm_s390_sync_request(int req, struct kvm_vcpu *vcpu);
276 277
int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu);
void kvm_s390_vcpu_unsetup_cmma(struct kvm_vcpu *vcpu);
278 279
unsigned long kvm_s390_fac_list_mask_size(void);
extern unsigned long kvm_s390_fac_list_mask[];
280 281
void kvm_s390_set_cpu_timer(struct kvm_vcpu *vcpu, __u64 cputm);
__u64 kvm_s390_get_cpu_timer(struct kvm_vcpu *vcpu);
282

283 284 285
/* implemented in diag.c */
int kvm_s390_handle_diag(struct kvm_vcpu *vcpu);

286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
static inline void kvm_s390_vcpu_block_all(struct kvm *kvm)
{
	int i;
	struct kvm_vcpu *vcpu;

	WARN_ON(!mutex_is_locked(&kvm->lock));
	kvm_for_each_vcpu(i, vcpu, kvm)
		kvm_s390_vcpu_block(vcpu);
}

static inline void kvm_s390_vcpu_unblock_all(struct kvm *kvm)
{
	int i;
	struct kvm_vcpu *vcpu;

	kvm_for_each_vcpu(i, vcpu, kvm)
		kvm_s390_vcpu_unblock(vcpu);
}

305 306 307 308 309 310 311 312 313 314
static inline u64 kvm_s390_get_tod_clock_fast(struct kvm *kvm)
{
	u64 rc;

	preempt_disable();
	rc = get_tod_clock_fast() + kvm->arch.epoch;
	preempt_enable();
	return rc;
}

315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
/**
 * kvm_s390_inject_prog_cond - conditionally inject a program check
 * @vcpu: virtual cpu
 * @rc: original return/error code
 *
 * This function is supposed to be used after regular guest access functions
 * failed, to conditionally inject a program check to a vcpu. The typical
 * pattern would look like
 *
 * rc = write_guest(vcpu, addr, data, len);
 * if (rc)
 *	return kvm_s390_inject_prog_cond(vcpu, rc);
 *
 * A negative return code from guest access functions implies an internal error
 * like e.g. out of memory. In these cases no program check should be injected
 * to the guest.
 * A positive value implies that an exception happened while accessing a guest's
 * memory. In this case all data belonging to the corresponding program check
 * has been stored in vcpu->arch.pgm and can be injected with
 * kvm_s390_inject_prog_irq().
 *
 * Returns: - the original @rc value if @rc was negative (internal error)
 *	    - zero if @rc was already zero
 *	    - zero or error code from injecting if @rc was positive
 *	      (program check injected to @vcpu)
 */
static inline int kvm_s390_inject_prog_cond(struct kvm_vcpu *vcpu, int rc)
{
	if (rc <= 0)
		return rc;
	return kvm_s390_inject_prog_irq(vcpu, &vcpu->arch.pgm);
}

348 349 350
int s390int_to_s390irq(struct kvm_s390_interrupt *s390int,
			struct kvm_s390_irq *s390irq);

351
/* implemented in interrupt.c */
352
int kvm_s390_vcpu_has_irq(struct kvm_vcpu *vcpu, int exclude_stop);
353
int psw_extint_disabled(struct kvm_vcpu *vcpu);
354
void kvm_s390_destroy_adapters(struct kvm *kvm);
355
int kvm_s390_ext_call_pending(struct kvm_vcpu *vcpu);
356
extern struct kvm_device_ops kvm_flic_ops;
357 358
int kvm_s390_is_stop_irq_pending(struct kvm_vcpu *vcpu);
void kvm_s390_clear_stop_irq(struct kvm_vcpu *vcpu);
359 360 361 362
int kvm_s390_set_irq_state(struct kvm_vcpu *vcpu,
			   void __user *buf, int len);
int kvm_s390_get_irq_state(struct kvm_vcpu *vcpu,
			   __u8 __user *buf, int len);
363

364 365 366 367 368 369 370 371 372 373
/* implemented in guestdbg.c */
void kvm_s390_backup_guest_per_regs(struct kvm_vcpu *vcpu);
void kvm_s390_restore_guest_per_regs(struct kvm_vcpu *vcpu);
void kvm_s390_patch_guest_per_regs(struct kvm_vcpu *vcpu);
int kvm_s390_import_bp_data(struct kvm_vcpu *vcpu,
			    struct kvm_guest_debug *dbg);
void kvm_s390_clear_bp_data(struct kvm_vcpu *vcpu);
void kvm_s390_prepare_debug_exit(struct kvm_vcpu *vcpu);
void kvm_s390_handle_per_event(struct kvm_vcpu *vcpu);

374 375 376
/* support for Basic/Extended SCA handling */
static inline union ipte_control *kvm_s390_get_ipte_control(struct kvm *kvm)
{
377 378 379
	struct bsca_block *sca = kvm->arch.sca; /* SCA version doesn't matter */

	return &sca->ipte_control;
380
}
381
#endif