1/*
2 * kvm guest debug support
3 *
4 * Copyright IBM Corp. 2014
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License (version 2 only)
8 * as published by the Free Software Foundation.
9 *
10 *    Author(s): David Hildenbrand <dahi@linux.vnet.ibm.com>
11 */
12#include <linux/kvm_host.h>
13#include <linux/errno.h>
14#include "kvm-s390.h"
15#include "gaccess.h"
16
17/*
18 * Extends the address range given by *start and *stop to include the address
19 * range starting with estart and the length len. Takes care of overflowing
20 * intervals and tries to minimize the overall intervall size.
21 */
22static void extend_address_range(u64 *start, u64 *stop, u64 estart, int len)
23{
24	u64 estop;
25
26	if (len > 0)
27		len--;
28	else
29		len = 0;
30
31	estop = estart + len;
32
33	/* 0-0 range represents "not set" */
34	if ((*start == 0) && (*stop == 0)) {
35		*start = estart;
36		*stop = estop;
37	} else if (*start <= *stop) {
38		/* increase the existing range */
39		if (estart < *start)
40			*start = estart;
41		if (estop > *stop)
42			*stop = estop;
43	} else {
44		/* "overflowing" interval, whereby *stop > *start */
45		if (estart <= *stop) {
46			if (estop > *stop)
47				*stop = estop;
48		} else if (estop > *start) {
49			if (estart < *start)
50				*start = estart;
51		}
52		/* minimize the range */
53		else if ((estop - *stop) < (*start - estart))
54			*stop = estop;
55		else
56			*start = estart;
57	}
58}
59
60#define MAX_INST_SIZE 6
61
62static void enable_all_hw_bp(struct kvm_vcpu *vcpu)
63{
64	unsigned long start, len;
65	u64 *cr9 = &vcpu->arch.sie_block->gcr[9];
66	u64 *cr10 = &vcpu->arch.sie_block->gcr[10];
67	u64 *cr11 = &vcpu->arch.sie_block->gcr[11];
68	int i;
69
70	if (vcpu->arch.guestdbg.nr_hw_bp <= 0 ||
71	    vcpu->arch.guestdbg.hw_bp_info == NULL)
72		return;
73
74	/*
75	 * If the guest is not interrested in branching events, we can savely
76	 * limit them to the PER address range.
77	 */
78	if (!(*cr9 & PER_EVENT_BRANCH))
79		*cr9 |= PER_CONTROL_BRANCH_ADDRESS;
80	*cr9 |= PER_EVENT_IFETCH | PER_EVENT_BRANCH;
81
82	for (i = 0; i < vcpu->arch.guestdbg.nr_hw_bp; i++) {
83		start = vcpu->arch.guestdbg.hw_bp_info[i].addr;
84		len = vcpu->arch.guestdbg.hw_bp_info[i].len;
85
86		/*
87		 * The instruction in front of the desired bp has to
88		 * report instruction-fetching events
89		 */
90		if (start < MAX_INST_SIZE) {
91			len += start;
92			start = 0;
93		} else {
94			start -= MAX_INST_SIZE;
95			len += MAX_INST_SIZE;
96		}
97
98		extend_address_range(cr10, cr11, start, len);
99	}
100}
101
102static void enable_all_hw_wp(struct kvm_vcpu *vcpu)
103{
104	unsigned long start, len;
105	u64 *cr9 = &vcpu->arch.sie_block->gcr[9];
106	u64 *cr10 = &vcpu->arch.sie_block->gcr[10];
107	u64 *cr11 = &vcpu->arch.sie_block->gcr[11];
108	int i;
109
110	if (vcpu->arch.guestdbg.nr_hw_wp <= 0 ||
111	    vcpu->arch.guestdbg.hw_wp_info == NULL)
112		return;
113
114	/* if host uses storage alternation for special address
115	 * spaces, enable all events and give all to the guest */
116	if (*cr9 & PER_EVENT_STORE && *cr9 & PER_CONTROL_ALTERATION) {
117		*cr9 &= ~PER_CONTROL_ALTERATION;
118		*cr10 = 0;
119		*cr11 = PSW_ADDR_INSN;
120	} else {
121		*cr9 &= ~PER_CONTROL_ALTERATION;
122		*cr9 |= PER_EVENT_STORE;
123
124		for (i = 0; i < vcpu->arch.guestdbg.nr_hw_wp; i++) {
125			start = vcpu->arch.guestdbg.hw_wp_info[i].addr;
126			len = vcpu->arch.guestdbg.hw_wp_info[i].len;
127
128			extend_address_range(cr10, cr11, start, len);
129		}
130	}
131}
132
133void kvm_s390_backup_guest_per_regs(struct kvm_vcpu *vcpu)
134{
135	vcpu->arch.guestdbg.cr0 = vcpu->arch.sie_block->gcr[0];
136	vcpu->arch.guestdbg.cr9 = vcpu->arch.sie_block->gcr[9];
137	vcpu->arch.guestdbg.cr10 = vcpu->arch.sie_block->gcr[10];
138	vcpu->arch.guestdbg.cr11 = vcpu->arch.sie_block->gcr[11];
139}
140
141void kvm_s390_restore_guest_per_regs(struct kvm_vcpu *vcpu)
142{
143	vcpu->arch.sie_block->gcr[0] = vcpu->arch.guestdbg.cr0;
144	vcpu->arch.sie_block->gcr[9] = vcpu->arch.guestdbg.cr9;
145	vcpu->arch.sie_block->gcr[10] = vcpu->arch.guestdbg.cr10;
146	vcpu->arch.sie_block->gcr[11] = vcpu->arch.guestdbg.cr11;
147}
148
149void kvm_s390_patch_guest_per_regs(struct kvm_vcpu *vcpu)
150{
151	/*
152	 * TODO: if guest psw has per enabled, otherwise 0s!
153	 * This reduces the amount of reported events.
154	 * Need to intercept all psw changes!
155	 */
156
157	if (guestdbg_sstep_enabled(vcpu)) {
158		/* disable timer (clock-comparator) interrupts */
159		vcpu->arch.sie_block->gcr[0] &= ~0x800ul;
160		vcpu->arch.sie_block->gcr[9] |= PER_EVENT_IFETCH;
161		vcpu->arch.sie_block->gcr[10] = 0;
162		vcpu->arch.sie_block->gcr[11] = PSW_ADDR_INSN;
163	}
164
165	if (guestdbg_hw_bp_enabled(vcpu)) {
166		enable_all_hw_bp(vcpu);
167		enable_all_hw_wp(vcpu);
168	}
169
170	/* TODO: Instruction-fetching-nullification not allowed for now */
171	if (vcpu->arch.sie_block->gcr[9] & PER_EVENT_NULLIFICATION)
172		vcpu->arch.sie_block->gcr[9] &= ~PER_EVENT_NULLIFICATION;
173}
174
175#define MAX_WP_SIZE 100
176
177static int __import_wp_info(struct kvm_vcpu *vcpu,
178			    struct kvm_hw_breakpoint *bp_data,
179			    struct kvm_hw_wp_info_arch *wp_info)
180{
181	int ret = 0;
182	wp_info->len = bp_data->len;
183	wp_info->addr = bp_data->addr;
184	wp_info->phys_addr = bp_data->phys_addr;
185	wp_info->old_data = NULL;
186
187	if (wp_info->len < 0 || wp_info->len > MAX_WP_SIZE)
188		return -EINVAL;
189
190	wp_info->old_data = kmalloc(bp_data->len, GFP_KERNEL);
191	if (!wp_info->old_data)
192		return -ENOMEM;
193	/* try to backup the original value */
194	ret = read_guest_abs(vcpu, wp_info->phys_addr, wp_info->old_data,
195			     wp_info->len);
196	if (ret) {
197		kfree(wp_info->old_data);
198		wp_info->old_data = NULL;
199	}
200
201	return ret;
202}
203
204#define MAX_BP_COUNT 50
205
206int kvm_s390_import_bp_data(struct kvm_vcpu *vcpu,
207			    struct kvm_guest_debug *dbg)
208{
209	int ret = 0, nr_wp = 0, nr_bp = 0, i, size;
210	struct kvm_hw_breakpoint *bp_data = NULL;
211	struct kvm_hw_wp_info_arch *wp_info = NULL;
212	struct kvm_hw_bp_info_arch *bp_info = NULL;
213
214	if (dbg->arch.nr_hw_bp <= 0 || !dbg->arch.hw_bp)
215		return 0;
216	else if (dbg->arch.nr_hw_bp > MAX_BP_COUNT)
217		return -EINVAL;
218
219	size = dbg->arch.nr_hw_bp * sizeof(struct kvm_hw_breakpoint);
220	bp_data = kmalloc(size, GFP_KERNEL);
221	if (!bp_data) {
222		ret = -ENOMEM;
223		goto error;
224	}
225
226	if (copy_from_user(bp_data, dbg->arch.hw_bp, size)) {
227		ret = -EFAULT;
228		goto error;
229	}
230
231	for (i = 0; i < dbg->arch.nr_hw_bp; i++) {
232		switch (bp_data[i].type) {
233		case KVM_HW_WP_WRITE:
234			nr_wp++;
235			break;
236		case KVM_HW_BP:
237			nr_bp++;
238			break;
239		default:
240			break;
241		}
242	}
243
244	size = nr_wp * sizeof(struct kvm_hw_wp_info_arch);
245	if (size > 0) {
246		wp_info = kmalloc(size, GFP_KERNEL);
247		if (!wp_info) {
248			ret = -ENOMEM;
249			goto error;
250		}
251	}
252	size = nr_bp * sizeof(struct kvm_hw_bp_info_arch);
253	if (size > 0) {
254		bp_info = kmalloc(size, GFP_KERNEL);
255		if (!bp_info) {
256			ret = -ENOMEM;
257			goto error;
258		}
259	}
260
261	for (nr_wp = 0, nr_bp = 0, i = 0; i < dbg->arch.nr_hw_bp; i++) {
262		switch (bp_data[i].type) {
263		case KVM_HW_WP_WRITE:
264			ret = __import_wp_info(vcpu, &bp_data[i],
265					       &wp_info[nr_wp]);
266			if (ret)
267				goto error;
268			nr_wp++;
269			break;
270		case KVM_HW_BP:
271			bp_info[nr_bp].len = bp_data[i].len;
272			bp_info[nr_bp].addr = bp_data[i].addr;
273			nr_bp++;
274			break;
275		}
276	}
277
278	vcpu->arch.guestdbg.nr_hw_bp = nr_bp;
279	vcpu->arch.guestdbg.hw_bp_info = bp_info;
280	vcpu->arch.guestdbg.nr_hw_wp = nr_wp;
281	vcpu->arch.guestdbg.hw_wp_info = wp_info;
282	return 0;
283error:
284	kfree(bp_data);
285	kfree(wp_info);
286	kfree(bp_info);
287	return ret;
288}
289
290void kvm_s390_clear_bp_data(struct kvm_vcpu *vcpu)
291{
292	int i;
293	struct kvm_hw_wp_info_arch *hw_wp_info = NULL;
294
295	for (i = 0; i < vcpu->arch.guestdbg.nr_hw_wp; i++) {
296		hw_wp_info = &vcpu->arch.guestdbg.hw_wp_info[i];
297		kfree(hw_wp_info->old_data);
298		hw_wp_info->old_data = NULL;
299	}
300	kfree(vcpu->arch.guestdbg.hw_wp_info);
301	vcpu->arch.guestdbg.hw_wp_info = NULL;
302
303	kfree(vcpu->arch.guestdbg.hw_bp_info);
304	vcpu->arch.guestdbg.hw_bp_info = NULL;
305
306	vcpu->arch.guestdbg.nr_hw_wp = 0;
307	vcpu->arch.guestdbg.nr_hw_bp = 0;
308}
309
310static inline int in_addr_range(u64 addr, u64 a, u64 b)
311{
312	if (a <= b)
313		return (addr >= a) && (addr <= b);
314	else
315		/* "overflowing" interval */
316		return (addr <= a) && (addr >= b);
317}
318
319#define end_of_range(bp_info) (bp_info->addr + bp_info->len - 1)
320
321static struct kvm_hw_bp_info_arch *find_hw_bp(struct kvm_vcpu *vcpu,
322					      unsigned long addr)
323{
324	struct kvm_hw_bp_info_arch *bp_info = vcpu->arch.guestdbg.hw_bp_info;
325	int i;
326
327	if (vcpu->arch.guestdbg.nr_hw_bp == 0)
328		return NULL;
329
330	for (i = 0; i < vcpu->arch.guestdbg.nr_hw_bp; i++) {
331		/* addr is directly the start or in the range of a bp */
332		if (addr == bp_info->addr)
333			goto found;
334		if (bp_info->len > 0 &&
335		    in_addr_range(addr, bp_info->addr, end_of_range(bp_info)))
336			goto found;
337
338		bp_info++;
339	}
340
341	return NULL;
342found:
343	return bp_info;
344}
345
346static struct kvm_hw_wp_info_arch *any_wp_changed(struct kvm_vcpu *vcpu)
347{
348	int i;
349	struct kvm_hw_wp_info_arch *wp_info = NULL;
350	void *temp = NULL;
351
352	if (vcpu->arch.guestdbg.nr_hw_wp == 0)
353		return NULL;
354
355	for (i = 0; i < vcpu->arch.guestdbg.nr_hw_wp; i++) {
356		wp_info = &vcpu->arch.guestdbg.hw_wp_info[i];
357		if (!wp_info || !wp_info->old_data || wp_info->len <= 0)
358			continue;
359
360		temp = kmalloc(wp_info->len, GFP_KERNEL);
361		if (!temp)
362			continue;
363
364		/* refetch the wp data and compare it to the old value */
365		if (!read_guest_abs(vcpu, wp_info->phys_addr, temp,
366				    wp_info->len)) {
367			if (memcmp(temp, wp_info->old_data, wp_info->len)) {
368				kfree(temp);
369				return wp_info;
370			}
371		}
372		kfree(temp);
373		temp = NULL;
374	}
375
376	return NULL;
377}
378
379void kvm_s390_prepare_debug_exit(struct kvm_vcpu *vcpu)
380{
381	vcpu->run->exit_reason = KVM_EXIT_DEBUG;
382	vcpu->guest_debug &= ~KVM_GUESTDBG_EXIT_PENDING;
383}
384
385#define per_bp_event(code) \
386			(code & (PER_EVENT_IFETCH | PER_EVENT_BRANCH))
387#define per_write_wp_event(code) \
388			(code & (PER_EVENT_STORE | PER_EVENT_STORE_REAL))
389
390static int debug_exit_required(struct kvm_vcpu *vcpu)
391{
392	u32 perc = (vcpu->arch.sie_block->perc << 24);
393	struct kvm_debug_exit_arch *debug_exit = &vcpu->run->debug.arch;
394	struct kvm_hw_wp_info_arch *wp_info = NULL;
395	struct kvm_hw_bp_info_arch *bp_info = NULL;
396	unsigned long addr = vcpu->arch.sie_block->gpsw.addr;
397	unsigned long peraddr = vcpu->arch.sie_block->peraddr;
398
399	if (guestdbg_hw_bp_enabled(vcpu)) {
400		if (per_write_wp_event(perc) &&
401		    vcpu->arch.guestdbg.nr_hw_wp > 0) {
402			wp_info = any_wp_changed(vcpu);
403			if (wp_info) {
404				debug_exit->addr = wp_info->addr;
405				debug_exit->type = KVM_HW_WP_WRITE;
406				goto exit_required;
407			}
408		}
409		if (per_bp_event(perc) &&
410			 vcpu->arch.guestdbg.nr_hw_bp > 0) {
411			bp_info = find_hw_bp(vcpu, addr);
412			/* remove duplicate events if PC==PER address */
413			if (bp_info && (addr != peraddr)) {
414				debug_exit->addr = addr;
415				debug_exit->type = KVM_HW_BP;
416				vcpu->arch.guestdbg.last_bp = addr;
417				goto exit_required;
418			}
419			/* breakpoint missed */
420			bp_info = find_hw_bp(vcpu, peraddr);
421			if (bp_info && vcpu->arch.guestdbg.last_bp != peraddr) {
422				debug_exit->addr = peraddr;
423				debug_exit->type = KVM_HW_BP;
424				goto exit_required;
425			}
426		}
427	}
428	if (guestdbg_sstep_enabled(vcpu) && per_bp_event(perc)) {
429		debug_exit->addr = addr;
430		debug_exit->type = KVM_SINGLESTEP;
431		goto exit_required;
432	}
433
434	return 0;
435exit_required:
436	return 1;
437}
438
439#define guest_per_enabled(vcpu) \
440			     (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PER)
441
442static void filter_guest_per_event(struct kvm_vcpu *vcpu)
443{
444	u32 perc = vcpu->arch.sie_block->perc << 24;
445	u64 peraddr = vcpu->arch.sie_block->peraddr;
446	u64 addr = vcpu->arch.sie_block->gpsw.addr;
447	u64 cr9 = vcpu->arch.sie_block->gcr[9];
448	u64 cr10 = vcpu->arch.sie_block->gcr[10];
449	u64 cr11 = vcpu->arch.sie_block->gcr[11];
450	/* filter all events, demanded by the guest */
451	u32 guest_perc = perc & cr9 & PER_EVENT_MASK;
452
453	if (!guest_per_enabled(vcpu))
454		guest_perc = 0;
455
456	/* filter "successful-branching" events */
457	if (guest_perc & PER_EVENT_BRANCH &&
458	    cr9 & PER_CONTROL_BRANCH_ADDRESS &&
459	    !in_addr_range(addr, cr10, cr11))
460		guest_perc &= ~PER_EVENT_BRANCH;
461
462	/* filter "instruction-fetching" events */
463	if (guest_perc & PER_EVENT_IFETCH &&
464	    !in_addr_range(peraddr, cr10, cr11))
465		guest_perc &= ~PER_EVENT_IFETCH;
466
467	/* All other PER events will be given to the guest */
468	/* TODO: Check alterated address/address space */
469
470	vcpu->arch.sie_block->perc = guest_perc >> 24;
471
472	if (!guest_perc)
473		vcpu->arch.sie_block->iprcc &= ~PGM_PER;
474}
475
476void kvm_s390_handle_per_event(struct kvm_vcpu *vcpu)
477{
478	if (debug_exit_required(vcpu))
479		vcpu->guest_debug |= KVM_GUESTDBG_EXIT_PENDING;
480
481	filter_guest_per_event(vcpu);
482}
483