arch/s390/kvm/guestdbg.c

   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 <[email protected]>
  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 interval size.
  21  */
  22 static 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
  62 static 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 interested in branching events, we can safely
  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
 102 static 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 = -1UL;
 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
 133 void 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
 141 void 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
 149 void 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] = -1UL;
 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
 177 static 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
 206 int 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;
 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         bp_data = memdup_user(dbg->arch.hw_bp,
 220                               sizeof(*bp_data) * dbg->arch.nr_hw_bp);
 221         if (IS_ERR(bp_data))
 222                 return PTR_ERR(bp_data);
 223
 224         for (i = 0; i < dbg->arch.nr_hw_bp; i++) {
 225                 switch (bp_data[i].type) {
 226                 case KVM_HW_WP_WRITE:
 227                         nr_wp++;
 228                         break;
 229                 case KVM_HW_BP:
 230                         nr_bp++;
 231                         break;
 232                 default:
 233                         break;
 234                 }
 235         }
 236
 237         if (nr_wp > 0) {
 238                 wp_info = kmalloc_array(nr_wp,
 239                                         sizeof(*wp_info),
 240                                         GFP_KERNEL);
 241                 if (!wp_info) {
 242                         ret = -ENOMEM;
 243                         goto error;
 244                 }
 245         }
 246         if (nr_bp > 0) {
 247                 bp_info = kmalloc_array(nr_bp,
 248                                         sizeof(*bp_info),
 249                                         GFP_KERNEL);
 250                 if (!bp_info) {
 251                         ret = -ENOMEM;
 252                         goto error;
 253                 }
 254         }
 255
 256         for (nr_wp = 0, nr_bp = 0, i = 0; i < dbg->arch.nr_hw_bp; i++) {
 257                 switch (bp_data[i].type) {
 258                 case KVM_HW_WP_WRITE:
 259                         ret = __import_wp_info(vcpu, &bp_data[i],
 260                                                &wp_info[nr_wp]);
 261                         if (ret)
 262                                 goto error;
 263                         nr_wp++;
 264                         break;
 265                 case KVM_HW_BP:
 266                         bp_info[nr_bp].len = bp_data[i].len;
 267                         bp_info[nr_bp].addr = bp_data[i].addr;
 268                         nr_bp++;
 269                         break;
 270                 }
 271         }
 272
 273         vcpu->arch.guestdbg.nr_hw_bp = nr_bp;
 274         vcpu->arch.guestdbg.hw_bp_info = bp_info;
 275         vcpu->arch.guestdbg.nr_hw_wp = nr_wp;
 276         vcpu->arch.guestdbg.hw_wp_info = wp_info;
 277         return 0;
 278 error:
 279         kfree(bp_data);
 280         kfree(wp_info);
 281         kfree(bp_info);
 282         return ret;
 283 }
 284
 285 void kvm_s390_clear_bp_data(struct kvm_vcpu *vcpu)
 286 {
 287         int i;
 288         struct kvm_hw_wp_info_arch *hw_wp_info = NULL;
 289
 290         for (i = 0; i < vcpu->arch.guestdbg.nr_hw_wp; i++) {
 291                 hw_wp_info = &vcpu->arch.guestdbg.hw_wp_info[i];
 292                 kfree(hw_wp_info->old_data);
 293                 hw_wp_info->old_data = NULL;
 294         }
 295         kfree(vcpu->arch.guestdbg.hw_wp_info);
 296         vcpu->arch.guestdbg.hw_wp_info = NULL;
 297
 298         kfree(vcpu->arch.guestdbg.hw_bp_info);
 299         vcpu->arch.guestdbg.hw_bp_info = NULL;
 300
 301         vcpu->arch.guestdbg.nr_hw_wp = 0;
 302         vcpu->arch.guestdbg.nr_hw_bp = 0;
 303 }
 304
 305 static inline int in_addr_range(u64 addr, u64 a, u64 b)
 306 {
 307         if (a <= b)
 308                 return (addr >= a) && (addr <= b);
 309         else
 310                 /* "overflowing" interval */
 311                 return (addr <= a) && (addr >= b);
 312 }
 313
 314 #define end_of_range(bp_info) (bp_info->addr + bp_info->len - 1)
 315
 316 static struct kvm_hw_bp_info_arch *find_hw_bp(struct kvm_vcpu *vcpu,
 317                                               unsigned long addr)
 318 {
 319         struct kvm_hw_bp_info_arch *bp_info = vcpu->arch.guestdbg.hw_bp_info;
 320         int i;
 321
 322         if (vcpu->arch.guestdbg.nr_hw_bp == 0)
 323                 return NULL;
 324
 325         for (i = 0; i < vcpu->arch.guestdbg.nr_hw_bp; i++) {
 326                 /* addr is directly the start or in the range of a bp */
 327                 if (addr == bp_info->addr)
 328                         goto found;
 329                 if (bp_info->len > 0 &&
 330                     in_addr_range(addr, bp_info->addr, end_of_range(bp_info)))
 331                         goto found;
 332
 333                 bp_info++;
 334         }
 335
 336         return NULL;
 337 found:
 338         return bp_info;
 339 }
 340
 341 static struct kvm_hw_wp_info_arch *any_wp_changed(struct kvm_vcpu *vcpu)
 342 {
 343         int i;
 344         struct kvm_hw_wp_info_arch *wp_info = NULL;
 345         void *temp = NULL;
 346
 347         if (vcpu->arch.guestdbg.nr_hw_wp == 0)
 348                 return NULL;
 349
 350         for (i = 0; i < vcpu->arch.guestdbg.nr_hw_wp; i++) {
 351                 wp_info = &vcpu->arch.guestdbg.hw_wp_info[i];
 352                 if (!wp_info || !wp_info->old_data || wp_info->len <= 0)
 353                         continue;
 354
 355                 temp = kmalloc(wp_info->len, GFP_KERNEL);
 356                 if (!temp)
 357                         continue;
 358
 359                 /* refetch the wp data and compare it to the old value */
 360                 if (!read_guest_abs(vcpu, wp_info->phys_addr, temp,
 361                                     wp_info->len)) {
 362                         if (memcmp(temp, wp_info->old_data, wp_info->len)) {
 363                                 kfree(temp);
 364                                 return wp_info;
 365                         }
 366                 }
 367                 kfree(temp);
 368                 temp = NULL;
 369         }
 370
 371         return NULL;
 372 }
 373
 374 void kvm_s390_prepare_debug_exit(struct kvm_vcpu *vcpu)
 375 {
 376         vcpu->run->exit_reason = KVM_EXIT_DEBUG;
 377         vcpu->guest_debug &= ~KVM_GUESTDBG_EXIT_PENDING;
 378 }
 379
 380 #define PER_CODE_MASK           (PER_EVENT_MASK >> 24)
 381 #define PER_CODE_BRANCH         (PER_EVENT_BRANCH >> 24)
 382 #define PER_CODE_IFETCH         (PER_EVENT_IFETCH >> 24)
 383 #define PER_CODE_STORE          (PER_EVENT_STORE >> 24)
 384 #define PER_CODE_STORE_REAL     (PER_EVENT_STORE_REAL >> 24)
 385
 386 #define per_bp_event(code) \
 387                         (code & (PER_CODE_IFETCH | PER_CODE_BRANCH))
 388 #define per_write_wp_event(code) \
 389                         (code & (PER_CODE_STORE | PER_CODE_STORE_REAL))
 390
 391 static int debug_exit_required(struct kvm_vcpu *vcpu, u8 perc,
 392                                unsigned long peraddr)
 393 {
 394         struct kvm_debug_exit_arch *debug_exit = &vcpu->run->debug.arch;
 395         struct kvm_hw_wp_info_arch *wp_info = NULL;
 396         struct kvm_hw_bp_info_arch *bp_info = NULL;
 397         unsigned long addr = vcpu->arch.sie_block->gpsw.addr;
 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;
 435 exit_required:
 436         return 1;
 437 }
 438
 439 static int per_fetched_addr(struct kvm_vcpu *vcpu, unsigned long *addr)
 440 {
 441         u8 exec_ilen = 0;
 442         u16 opcode[3];
 443         int rc;
 444
 445         if (vcpu->arch.sie_block->icptcode == ICPT_PROGI) {
 446                 /* PER address references the fetched or the execute instr */
 447                 *addr = vcpu->arch.sie_block->peraddr;
 448                 /*
 449                  * Manually detect if we have an EXECUTE instruction. As
 450                  * instructions are always 2 byte aligned we can read the
 451                  * first two bytes unconditionally
 452                  */
 453                 rc = read_guest_instr(vcpu, *addr, &opcode, 2);
 454                 if (rc)
 455                         return rc;
 456                 if (opcode[0] >> 8 == 0x44)
 457                         exec_ilen = 4;
 458                 if ((opcode[0] & 0xff0f) == 0xc600)
 459                         exec_ilen = 6;
 460         } else {
 461                 /* instr was suppressed, calculate the responsible instr */
 462                 *addr = __rewind_psw(vcpu->arch.sie_block->gpsw,
 463                                      kvm_s390_get_ilen(vcpu));
 464                 if (vcpu->arch.sie_block->icptstatus & 0x01) {
 465                         exec_ilen = (vcpu->arch.sie_block->icptstatus & 0x60) >> 4;
 466                         if (!exec_ilen)
 467                                 exec_ilen = 4;
 468                 }
 469         }
 470
 471         if (exec_ilen) {
 472                 /* read the complete EXECUTE instr to detect the fetched addr */
 473                 rc = read_guest_instr(vcpu, *addr, &opcode, exec_ilen);
 474                 if (rc)
 475                         return rc;
 476                 if (exec_ilen == 6) {
 477                         /* EXECUTE RELATIVE LONG - RIL-b format */
 478                         s32 rl = *((s32 *) (opcode + 1));
 479
 480                         /* rl is a _signed_ 32 bit value specifying halfwords */
 481                         *addr += (u64)(s64) rl * 2;
 482                 } else {
 483                         /* EXECUTE - RX-a format */
 484                         u32 base = (opcode[1] & 0xf000) >> 12;
 485                         u32 disp = opcode[1] & 0x0fff;
 486                         u32 index = opcode[0] & 0x000f;
 487
 488                         *addr = base ? vcpu->run->s.regs.gprs[base] : 0;
 489                         *addr += index ? vcpu->run->s.regs.gprs[index] : 0;
 490                         *addr += disp;
 491                 }
 492                 *addr = kvm_s390_logical_to_effective(vcpu, *addr);
 493         }
 494         return 0;
 495 }
 496
 497 #define guest_per_enabled(vcpu) \
 498                              (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PER)
 499
 500 int kvm_s390_handle_per_ifetch_icpt(struct kvm_vcpu *vcpu)
 501 {
 502         const u64 cr10 = vcpu->arch.sie_block->gcr[10];
 503         const u64 cr11 = vcpu->arch.sie_block->gcr[11];
 504         const u8 ilen = kvm_s390_get_ilen(vcpu);
 505         struct kvm_s390_pgm_info pgm_info = {
 506                 .code = PGM_PER,
 507                 .per_code = PER_CODE_IFETCH,
 508                 .per_address = __rewind_psw(vcpu->arch.sie_block->gpsw, ilen),
 509         };
 510         unsigned long fetched_addr;
 511         int rc;
 512
 513         /*
 514          * The PSW points to the next instruction, therefore the intercepted
 515          * instruction generated a PER i-fetch event. PER address therefore
 516          * points at the previous PSW address (could be an EXECUTE function).
 517          */
 518         if (!guestdbg_enabled(vcpu))
 519                 return kvm_s390_inject_prog_irq(vcpu, &pgm_info);
 520
 521         if (debug_exit_required(vcpu, pgm_info.per_code, pgm_info.per_address))
 522                 vcpu->guest_debug |= KVM_GUESTDBG_EXIT_PENDING;
 523
 524         if (!guest_per_enabled(vcpu) ||
 525             !(vcpu->arch.sie_block->gcr[9] & PER_EVENT_IFETCH))
 526                 return 0;
 527
 528         rc = per_fetched_addr(vcpu, &fetched_addr);
 529         if (rc < 0)
 530                 return rc;
 531         if (rc)
 532                 /* instruction-fetching exceptions */
 533                 return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
 534
 535         if (in_addr_range(fetched_addr, cr10, cr11))
 536                 return kvm_s390_inject_prog_irq(vcpu, &pgm_info);
 537         return 0;
 538 }
 539
 540 static int filter_guest_per_event(struct kvm_vcpu *vcpu)
 541 {
 542         const u8 perc = vcpu->arch.sie_block->perc;
 543         u64 addr = vcpu->arch.sie_block->gpsw.addr;
 544         u64 cr9 = vcpu->arch.sie_block->gcr[9];
 545         u64 cr10 = vcpu->arch.sie_block->gcr[10];
 546         u64 cr11 = vcpu->arch.sie_block->gcr[11];
 547         /* filter all events, demanded by the guest */
 548         u8 guest_perc = perc & (cr9 >> 24) & PER_CODE_MASK;
 549         unsigned long fetched_addr;
 550         int rc;
 551
 552         if (!guest_per_enabled(vcpu))
 553                 guest_perc = 0;
 554
 555         /* filter "successful-branching" events */
 556         if (guest_perc & PER_CODE_BRANCH &&
 557             cr9 & PER_CONTROL_BRANCH_ADDRESS &&
 558             !in_addr_range(addr, cr10, cr11))
 559                 guest_perc &= ~PER_CODE_BRANCH;
 560
 561         /* filter "instruction-fetching" events */
 562         if (guest_perc & PER_CODE_IFETCH) {
 563                 rc = per_fetched_addr(vcpu, &fetched_addr);
 564                 if (rc < 0)
 565                         return rc;
 566                 /*
 567                  * Don't inject an irq on exceptions. This would make handling
 568                  * on icpt code 8 very complex (as PSW was already rewound).
 569                  */
 570                 if (rc || !in_addr_range(fetched_addr, cr10, cr11))
 571                         guest_perc &= ~PER_CODE_IFETCH;
 572         }
 573
 574         /* All other PER events will be given to the guest */
 575         /* TODO: Check altered address/address space */
 576
 577         vcpu->arch.sie_block->perc = guest_perc;
 578
 579         if (!guest_perc)
 580                 vcpu->arch.sie_block->iprcc &= ~PGM_PER;
 581         return 0;
 582 }
 583
 584 #define pssec(vcpu) (vcpu->arch.sie_block->gcr[1] & _ASCE_SPACE_SWITCH)
 585 #define hssec(vcpu) (vcpu->arch.sie_block->gcr[13] & _ASCE_SPACE_SWITCH)
 586 #define old_ssec(vcpu) ((vcpu->arch.sie_block->tecmc >> 31) & 0x1)
 587 #define old_as_is_home(vcpu) !(vcpu->arch.sie_block->tecmc & 0xffff)
 588
 589 int kvm_s390_handle_per_event(struct kvm_vcpu *vcpu)
 590 {
 591         int rc, new_as;
 592
 593         if (debug_exit_required(vcpu, vcpu->arch.sie_block->perc,
 594                                 vcpu->arch.sie_block->peraddr))
 595                 vcpu->guest_debug |= KVM_GUESTDBG_EXIT_PENDING;
 596
 597         rc = filter_guest_per_event(vcpu);
 598         if (rc)
 599                 return rc;
 600
 601         /*
 602          * Only RP, SAC, SACF, PT, PTI, PR, PC instructions can trigger
 603          * a space-switch event. PER events enforce space-switch events
 604          * for these instructions. So if no PER event for the guest is left,
 605          * we might have to filter the space-switch element out, too.
 606          */
 607         if (vcpu->arch.sie_block->iprcc == PGM_SPACE_SWITCH) {
 608                 vcpu->arch.sie_block->iprcc = 0;
 609                 new_as = psw_bits(vcpu->arch.sie_block->gpsw).as;
 610
 611                 /*
 612                  * If the AS changed from / to home, we had RP, SAC or SACF
 613                  * instruction. Check primary and home space-switch-event
 614                  * controls. (theoretically home -> home produced no event)
 615                  */
 616                 if (((new_as == PSW_BITS_AS_HOME) ^ old_as_is_home(vcpu)) &&
 617                     (pssec(vcpu) || hssec(vcpu)))
 618                         vcpu->arch.sie_block->iprcc = PGM_SPACE_SWITCH;
 619
 620                 /*
 621                  * PT, PTI, PR, PC instruction operate on primary AS only. Check
 622                  * if the primary-space-switch-event control was or got set.
 623                  */
 624                 if (new_as == PSW_BITS_AS_PRIMARY && !old_as_is_home(vcpu) &&
 625                     (pssec(vcpu) || old_ssec(vcpu)))
 626                         vcpu->arch.sie_block->iprcc = PGM_SPACE_SWITCH;
 627         }
 628         return 0;
 629 }