projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
KVM: s390: write external damage code on machine checks
[linux-2.6-block.git] / arch / s390 / kvm / guestdbg.c
CommitLineData
27291e21
DH		 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
7eb792bf 20 * intervals and tries to minimize the overall interval size.
27291e21
DH		 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 /*
7eb792bf 75 * If the guest is not interested in branching events, we can safely
27291e21
DH		 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;
9cb1ccec 119 *cr11 = -1UL;
27291e21
DH		 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)) {
f71d0dc5
DH		 158 /* disable timer (clock-comparator) interrupts */
159 vcpu->arch.sie_block->gcr[0] &= ~0x800ul;
27291e21
DH		 160 vcpu->arch.sie_block->gcr[9] |= PER_EVENT_IFETCH;
161 vcpu->arch.sie_block->gcr[10] = 0;
9cb1ccec 162 vcpu->arch.sie_block->gcr[11] = -1UL;
27291e21
DH		 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 */
1f289a84
AY		 194 ret = read_guest_abs(vcpu, wp_info->phys_addr, wp_info->old_data,
195 wp_info->len);
27291e21
DH		 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
fcc9aec3
DC		 226 if (copy_from_user(bp_data, dbg->arch.hw_bp, size)) {
227 ret = -EFAULT;
27291e21 228 goto error;
fcc9aec3 229 }
27291e21
DH		 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 */
1f289a84
AY		 365 if (!read_guest_abs(vcpu, wp_info->phys_addr, temp,
366 wp_info->len)) {
27291e21
DH		 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
5ffe466c
DH		 442int kvm_s390_handle_per_ifetch_icpt(struct kvm_vcpu *vcpu)
443{
444 const u8 ilen = kvm_s390_get_ilen(vcpu);
445 struct kvm_s390_pgm_info pgm_info = {
446 .code = PGM_PER,
447 .per_code = PER_EVENT_IFETCH >> 24,
448 .per_address = __rewind_psw(vcpu->arch.sie_block->gpsw, ilen),
449 };
450
451 /*
452 * The PSW points to the next instruction, therefore the intercepted
453 * instruction generated a PER i-fetch event. PER address therefore
454 * points at the previous PSW address (could be an EXECUTE function).
455 */
456 return kvm_s390_inject_prog_irq(vcpu, &pgm_info);
457}
458
27291e21
DH		 459static void filter_guest_per_event(struct kvm_vcpu *vcpu)
460{
461 u32 perc = vcpu->arch.sie_block->perc << 24;
462 u64 peraddr = vcpu->arch.sie_block->peraddr;
463 u64 addr = vcpu->arch.sie_block->gpsw.addr;
464 u64 cr9 = vcpu->arch.sie_block->gcr[9];
465 u64 cr10 = vcpu->arch.sie_block->gcr[10];
466 u64 cr11 = vcpu->arch.sie_block->gcr[11];
467 /* filter all events, demanded by the guest */
468 u32 guest_perc = perc & cr9 & PER_EVENT_MASK;
469
470 if (!guest_per_enabled(vcpu))
471 guest_perc = 0;
472
473 /* filter "successful-branching" events */
474 if (guest_perc & PER_EVENT_BRANCH &&
475 cr9 & PER_CONTROL_BRANCH_ADDRESS &&
476 !in_addr_range(addr, cr10, cr11))
477 guest_perc &= ~PER_EVENT_BRANCH;
478
479 /* filter "instruction-fetching" events */
480 if (guest_perc & PER_EVENT_IFETCH &&
481 !in_addr_range(peraddr, cr10, cr11))
482 guest_perc &= ~PER_EVENT_IFETCH;
483
484 /* All other PER events will be given to the guest */
960cb306 485 /* TODO: Check altered address/address space */
27291e21
DH		 486
487 vcpu->arch.sie_block->perc = guest_perc >> 24;
488
489 if (!guest_perc)
490 vcpu->arch.sie_block->iprcc &= ~PGM_PER;
491}
492
0df30abc
DH		 493#define pssec(vcpu) (vcpu->arch.sie_block->gcr[1] & _ASCE_SPACE_SWITCH)
494#define hssec(vcpu) (vcpu->arch.sie_block->gcr[13] & _ASCE_SPACE_SWITCH)
495#define old_ssec(vcpu) ((vcpu->arch.sie_block->tecmc >> 31) & 0x1)
496#define old_as_is_home(vcpu) !(vcpu->arch.sie_block->tecmc & 0xffff)
497
27291e21
DH		 498void kvm_s390_handle_per_event(struct kvm_vcpu *vcpu)
499{
0df30abc
DH		 500 int new_as;
501
27291e21
DH		 502 if (debug_exit_required(vcpu))
503 vcpu->guest_debug |= KVM_GUESTDBG_EXIT_PENDING;
504
505 filter_guest_per_event(vcpu);
0df30abc
DH		 506
507 /*
508 * Only RP, SAC, SACF, PT, PTI, PR, PC instructions can trigger
509 * a space-switch event. PER events enforce space-switch events
510 * for these instructions. So if no PER event for the guest is left,
511 * we might have to filter the space-switch element out, too.
512 */
513 if (vcpu->arch.sie_block->iprcc == PGM_SPACE_SWITCH) {
514 vcpu->arch.sie_block->iprcc = 0;
515 new_as = psw_bits(vcpu->arch.sie_block->gpsw).as;
516
517 /*
518 * If the AS changed from / to home, we had RP, SAC or SACF
519 * instruction. Check primary and home space-switch-event
520 * controls. (theoretically home -> home produced no event)
521 */
522 if (((new_as == PSW_AS_HOME) ^ old_as_is_home(vcpu)) &&
523 (pssec(vcpu) || hssec(vcpu)))
524 vcpu->arch.sie_block->iprcc = PGM_SPACE_SWITCH;
525
526 /*
527 * PT, PTI, PR, PC instruction operate on primary AS only. Check
528 * if the primary-space-switch-event control was or got set.
529 */
530 if (new_as == PSW_AS_PRIMARY && !old_as_is_home(vcpu) &&
531 (pssec(vcpu) || old_ssec(vcpu)))
532 vcpu->arch.sie_block->iprcc = PGM_SPACE_SWITCH;
533 }
27291e21 534}
Linux 6.x block layer and io_uring tree(s)