arch/s390/kvm/intercept.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * in-kernel handling for sie intercepts
   4  *
   5  * Copyright IBM Corp. 2008, 2014
   6  *
   7  *    Author(s): Carsten Otte <cotte@de.ibm.com>
   8  *               Christian Borntraeger <borntraeger@de.ibm.com>
   9  */
  10
  11 #include <linux/kvm_host.h>
  12 #include <linux/errno.h>
  13 #include <linux/pagemap.h>
  14
  15 #include <asm/kvm_host.h>
  16 #include <asm/asm-offsets.h>
  17 #include <asm/irq.h>
  18 #include <asm/sysinfo.h>
  19
  20 #include "kvm-s390.h"
  21 #include "gaccess.h"
  22 #include "trace.h"
  23 #include "trace-s390.h"
  24
  25 u8 kvm_s390_get_ilen(struct kvm_vcpu *vcpu)
  26 {
  27         struct kvm_s390_sie_block *sie_block = vcpu->arch.sie_block;
  28         u8 ilen = 0;
  29
  30         switch (vcpu->arch.sie_block->icptcode) {
  31         case ICPT_INST:
  32         case ICPT_INSTPROGI:
  33         case ICPT_OPEREXC:
  34         case ICPT_PARTEXEC:
  35         case ICPT_IOINST:
  36                 /* instruction only stored for these icptcodes */
  37                 ilen = insn_length(vcpu->arch.sie_block->ipa >> 8);
  38                 /* Use the length of the EXECUTE instruction if necessary */
  39                 if (sie_block->icptstatus & 1) {
  40                         ilen = (sie_block->icptstatus >> 4) & 0x6;
  41                         if (!ilen)
  42                                 ilen = 4;
  43                 }
  44                 break;
  45         case ICPT_PROGI:
  46                 /* bit 1+2 of pgmilc are the ilc, so we directly get ilen */
  47                 ilen = vcpu->arch.sie_block->pgmilc & 0x6;
  48                 break;
  49         }
  50         return ilen;
  51 }
  52
  53 static int handle_noop(struct kvm_vcpu *vcpu)
  54 {
  55         switch (vcpu->arch.sie_block->icptcode) {
  56         case 0x10:
  57                 vcpu->stat.exit_external_request++;
  58                 break;
  59         default:
  60                 break; /* nothing */
  61         }
  62         return 0;
  63 }
  64
  65 static int handle_stop(struct kvm_vcpu *vcpu)
  66 {
  67         struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
  68         int rc = 0;
  69         uint8_t flags, stop_pending;
  70
  71         vcpu->stat.exit_stop_request++;
  72
  73         /* delay the stop if any non-stop irq is pending */
  74         if (kvm_s390_vcpu_has_irq(vcpu, 1))
  75                 return 0;
  76
  77         /* avoid races with the injection/SIGP STOP code */
  78         spin_lock(&li->lock);
  79         flags = li->irq.stop.flags;
  80         stop_pending = kvm_s390_is_stop_irq_pending(vcpu);
  81         spin_unlock(&li->lock);
  82
  83         trace_kvm_s390_stop_request(stop_pending, flags);
  84         if (!stop_pending)
  85                 return 0;
  86
  87         if (flags & KVM_S390_STOP_FLAG_STORE_STATUS) {
  88                 rc = kvm_s390_vcpu_store_status(vcpu,
  89                                                 KVM_S390_STORE_STATUS_NOADDR);
  90                 if (rc)
  91                         return rc;
  92         }
  93
  94         if (!kvm_s390_user_cpu_state_ctrl(vcpu->kvm))
  95                 kvm_s390_vcpu_stop(vcpu);
  96         return -EOPNOTSUPP;
  97 }
  98
  99 static int handle_validity(struct kvm_vcpu *vcpu)
 100 {
 101         int viwhy = vcpu->arch.sie_block->ipb >> 16;
 102
 103         vcpu->stat.exit_validity++;
 104         trace_kvm_s390_intercept_validity(vcpu, viwhy);
 105         KVM_EVENT(3, "validity intercept 0x%x for pid %u (kvm 0x%pK)", viwhy,
 106                   current->pid, vcpu->kvm);
 107
 108         /* do not warn on invalid runtime instrumentation mode */
 109         WARN_ONCE(viwhy != 0x44, "kvm: unhandled validity intercept 0x%x\n",
 110                   viwhy);
 111         return -EINVAL;
 112 }
 113
 114 static int handle_instruction(struct kvm_vcpu *vcpu)
 115 {
 116         vcpu->stat.exit_instruction++;
 117         trace_kvm_s390_intercept_instruction(vcpu,
 118                                              vcpu->arch.sie_block->ipa,
 119                                              vcpu->arch.sie_block->ipb);
 120
 121         switch (vcpu->arch.sie_block->ipa >> 8) {
 122         case 0x01:
 123                 return kvm_s390_handle_01(vcpu);
 124         case 0x82:
 125                 return kvm_s390_handle_lpsw(vcpu);
 126         case 0x83:
 127                 return kvm_s390_handle_diag(vcpu);
 128         case 0xaa:
 129                 return kvm_s390_handle_aa(vcpu);
 130         case 0xae:
 131                 return kvm_s390_handle_sigp(vcpu);
 132         case 0xb2:
 133                 return kvm_s390_handle_b2(vcpu);
 134         case 0xb6:
 135                 return kvm_s390_handle_stctl(vcpu);
 136         case 0xb7:
 137                 return kvm_s390_handle_lctl(vcpu);
 138         case 0xb9:
 139                 return kvm_s390_handle_b9(vcpu);
 140         case 0xe3:
 141                 return kvm_s390_handle_e3(vcpu);
 142         case 0xe5:
 143                 return kvm_s390_handle_e5(vcpu);
 144         case 0xeb:
 145                 return kvm_s390_handle_eb(vcpu);
 146         default:
 147                 return -EOPNOTSUPP;
 148         }
 149 }
 150
 151 static int inject_prog_on_prog_intercept(struct kvm_vcpu *vcpu)
 152 {
 153         struct kvm_s390_pgm_info pgm_info = {
 154                 .code = vcpu->arch.sie_block->iprcc,
 155                 /* the PSW has already been rewound */
 156                 .flags = KVM_S390_PGM_FLAGS_NO_REWIND,
 157         };
 158
 159         switch (vcpu->arch.sie_block->iprcc & ~PGM_PER) {
 160         case PGM_AFX_TRANSLATION:
 161         case PGM_ASX_TRANSLATION:
 162         case PGM_EX_TRANSLATION:
 163         case PGM_LFX_TRANSLATION:
 164         case PGM_LSTE_SEQUENCE:
 165         case PGM_LSX_TRANSLATION:
 166         case PGM_LX_TRANSLATION:
 167         case PGM_PRIMARY_AUTHORITY:
 168         case PGM_SECONDARY_AUTHORITY:
 169         case PGM_SPACE_SWITCH:
 170                 pgm_info.trans_exc_code = vcpu->arch.sie_block->tecmc;
 171                 break;
 172         case PGM_ALEN_TRANSLATION:
 173         case PGM_ALE_SEQUENCE:
 174         case PGM_ASTE_INSTANCE:
 175         case PGM_ASTE_SEQUENCE:
 176         case PGM_ASTE_VALIDITY:
 177         case PGM_EXTENDED_AUTHORITY:
 178                 pgm_info.exc_access_id = vcpu->arch.sie_block->eai;
 179                 break;
 180         case PGM_ASCE_TYPE:
 181         case PGM_PAGE_TRANSLATION:
 182         case PGM_REGION_FIRST_TRANS:
 183         case PGM_REGION_SECOND_TRANS:
 184         case PGM_REGION_THIRD_TRANS:
 185         case PGM_SEGMENT_TRANSLATION:
 186                 pgm_info.trans_exc_code = vcpu->arch.sie_block->tecmc;
 187                 pgm_info.exc_access_id  = vcpu->arch.sie_block->eai;
 188                 pgm_info.op_access_id  = vcpu->arch.sie_block->oai;
 189                 break;
 190         case PGM_MONITOR:
 191                 pgm_info.mon_class_nr = vcpu->arch.sie_block->mcn;
 192                 pgm_info.mon_code = vcpu->arch.sie_block->tecmc;
 193                 break;
 194         case PGM_VECTOR_PROCESSING:
 195         case PGM_DATA:
 196                 pgm_info.data_exc_code = vcpu->arch.sie_block->dxc;
 197                 break;
 198         case PGM_PROTECTION:
 199                 pgm_info.trans_exc_code = vcpu->arch.sie_block->tecmc;
 200                 pgm_info.exc_access_id  = vcpu->arch.sie_block->eai;
 201                 break;
 202         default:
 203                 break;
 204         }
 205
 206         if (vcpu->arch.sie_block->iprcc & PGM_PER) {
 207                 pgm_info.per_code = vcpu->arch.sie_block->perc;
 208                 pgm_info.per_atmid = vcpu->arch.sie_block->peratmid;
 209                 pgm_info.per_address = vcpu->arch.sie_block->peraddr;
 210                 pgm_info.per_access_id = vcpu->arch.sie_block->peraid;
 211         }
 212         return kvm_s390_inject_prog_irq(vcpu, &pgm_info);
 213 }
 214
 215 /*
 216  * restore ITDB to program-interruption TDB in guest lowcore
 217  * and set TX abort indication if required
 218 */
 219 static int handle_itdb(struct kvm_vcpu *vcpu)
 220 {
 221         struct kvm_s390_itdb *itdb;
 222         int rc;
 223
 224         if (!IS_TE_ENABLED(vcpu) || !IS_ITDB_VALID(vcpu))
 225                 return 0;
 226         if (current->thread.per_flags & PER_FLAG_NO_TE)
 227                 return 0;
 228         itdb = (struct kvm_s390_itdb *)vcpu->arch.sie_block->itdba;
 229         rc = write_guest_lc(vcpu, __LC_PGM_TDB, itdb, sizeof(*itdb));
 230         if (rc)
 231                 return rc;
 232         memset(itdb, 0, sizeof(*itdb));
 233
 234         return 0;
 235 }
 236
 237 #define per_event(vcpu) (vcpu->arch.sie_block->iprcc & PGM_PER)
 238
 239 static int handle_prog(struct kvm_vcpu *vcpu)
 240 {
 241         psw_t psw;
 242         int rc;
 243
 244         vcpu->stat.exit_program_interruption++;
 245
 246         if (guestdbg_enabled(vcpu) && per_event(vcpu)) {
 247                 rc = kvm_s390_handle_per_event(vcpu);
 248                 if (rc)
 249                         return rc;
 250                 /* the interrupt might have been filtered out completely */
 251                 if (vcpu->arch.sie_block->iprcc == 0)
 252                         return 0;
 253         }
 254
 255         trace_kvm_s390_intercept_prog(vcpu, vcpu->arch.sie_block->iprcc);
 256         if (vcpu->arch.sie_block->iprcc == PGM_SPECIFICATION) {
 257                 rc = read_guest_lc(vcpu, __LC_PGM_NEW_PSW, &psw, sizeof(psw_t));
 258                 if (rc)
 259                         return rc;
 260                 /* Avoid endless loops of specification exceptions */
 261                 if (!is_valid_psw(&psw))
 262                         return -EOPNOTSUPP;
 263         }
 264         rc = handle_itdb(vcpu);
 265         if (rc)
 266                 return rc;
 267
 268         return inject_prog_on_prog_intercept(vcpu);
 269 }
 270
 271 /**
 272  * handle_external_interrupt - used for external interruption interceptions
 273  *
 274  * This interception only occurs if the CPUSTAT_EXT_INT bit was set, or if
 275  * the new PSW does not have external interrupts disabled. In the first case,
 276  * we've got to deliver the interrupt manually, and in the second case, we
 277  * drop to userspace to handle the situation there.
 278  */
 279 static int handle_external_interrupt(struct kvm_vcpu *vcpu)
 280 {
 281         u16 eic = vcpu->arch.sie_block->eic;
 282         struct kvm_s390_irq irq;
 283         psw_t newpsw;
 284         int rc;
 285
 286         vcpu->stat.exit_external_interrupt++;
 287
 288         rc = read_guest_lc(vcpu, __LC_EXT_NEW_PSW, &newpsw, sizeof(psw_t));
 289         if (rc)
 290                 return rc;
 291         /* We can not handle clock comparator or timer interrupt with bad PSW */
 292         if ((eic == EXT_IRQ_CLK_COMP || eic == EXT_IRQ_CPU_TIMER) &&
 293             (newpsw.mask & PSW_MASK_EXT))
 294                 return -EOPNOTSUPP;
 295
 296         switch (eic) {
 297         case EXT_IRQ_CLK_COMP:
 298                 irq.type = KVM_S390_INT_CLOCK_COMP;
 299                 break;
 300         case EXT_IRQ_CPU_TIMER:
 301                 irq.type = KVM_S390_INT_CPU_TIMER;
 302                 break;
 303         case EXT_IRQ_EXTERNAL_CALL:
 304                 irq.type = KVM_S390_INT_EXTERNAL_CALL;
 305                 irq.u.extcall.code = vcpu->arch.sie_block->extcpuaddr;
 306                 rc = kvm_s390_inject_vcpu(vcpu, &irq);
 307                 /* ignore if another external call is already pending */
 308                 if (rc == -EBUSY)
 309                         return 0;
 310                 return rc;
 311         default:
 312                 return -EOPNOTSUPP;
 313         }
 314
 315         return kvm_s390_inject_vcpu(vcpu, &irq);
 316 }
 317
 318 /**
 319  * Handle MOVE PAGE partial execution interception.
 320  *
 321  * This interception can only happen for guests with DAT disabled and
 322  * addresses that are currently not mapped in the host. Thus we try to
 323  * set up the mappings for the corresponding user pages here (or throw
 324  * addressing exceptions in case of illegal guest addresses).
 325  */
 326 static int handle_mvpg_pei(struct kvm_vcpu *vcpu)
 327 {
 328         unsigned long srcaddr, dstaddr;
 329         int reg1, reg2, rc;
 330
 331         kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);
 332
 333         /* Make sure that the source is paged-in */
 334         rc = guest_translate_address(vcpu, vcpu->run->s.regs.gprs[reg2],
 335                                      reg2, &srcaddr, GACC_FETCH);
 336         if (rc)
 337                 return kvm_s390_inject_prog_cond(vcpu, rc);
 338         rc = kvm_arch_fault_in_page(vcpu, srcaddr, 0);
 339         if (rc != 0)
 340                 return rc;
 341
 342         /* Make sure that the destination is paged-in */
 343         rc = guest_translate_address(vcpu, vcpu->run->s.regs.gprs[reg1],
 344                                      reg1, &dstaddr, GACC_STORE);
 345         if (rc)
 346                 return kvm_s390_inject_prog_cond(vcpu, rc);
 347         rc = kvm_arch_fault_in_page(vcpu, dstaddr, 1);
 348         if (rc != 0)
 349                 return rc;
 350
 351         kvm_s390_retry_instr(vcpu);
 352
 353         return 0;
 354 }
 355
 356 static int handle_partial_execution(struct kvm_vcpu *vcpu)
 357 {
 358         vcpu->stat.exit_pei++;
 359
 360         if (vcpu->arch.sie_block->ipa == 0xb254)        /* MVPG */
 361                 return handle_mvpg_pei(vcpu);
 362         if (vcpu->arch.sie_block->ipa >> 8 == 0xae)     /* SIGP */
 363                 return kvm_s390_handle_sigp_pei(vcpu);
 364
 365         return -EOPNOTSUPP;
 366 }
 367
 368 /*
 369  * Handle the sthyi instruction that provides the guest with system
 370  * information, like current CPU resources available at each level of
 371  * the machine.
 372  */
 373 int handle_sthyi(struct kvm_vcpu *vcpu)
 374 {
 375         int reg1, reg2, r = 0;
 376         u64 code, addr, cc = 0, rc = 0;
 377         struct sthyi_sctns *sctns = NULL;
 378
 379         if (!test_kvm_facility(vcpu->kvm, 74))
 380                 return kvm_s390_inject_program_int(vcpu, PGM_OPERATION);
 381
 382         kvm_s390_get_regs_rre(vcpu, &reg1, &reg2);
 383         code = vcpu->run->s.regs.gprs[reg1];
 384         addr = vcpu->run->s.regs.gprs[reg2];
 385
 386         vcpu->stat.instruction_sthyi++;
 387         VCPU_EVENT(vcpu, 3, "STHYI: fc: %llu addr: 0x%016llx", code, addr);
 388         trace_kvm_s390_handle_sthyi(vcpu, code, addr);
 389
 390         if (reg1 == reg2 || reg1 & 1 || reg2 & 1)
 391                 return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
 392
 393         if (code & 0xffff) {
 394                 cc = 3;
 395                 rc = 4;
 396                 goto out;
 397         }
 398
 399         if (addr & ~PAGE_MASK)
 400                 return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
 401
 402         sctns = (void *)get_zeroed_page(GFP_KERNEL);
 403         if (!sctns)
 404                 return -ENOMEM;
 405
 406         cc = sthyi_fill(sctns, &rc);
 407
 408 out:
 409         if (!cc) {
 410                 r = write_guest(vcpu, addr, reg2, sctns, PAGE_SIZE);
 411                 if (r) {
 412                         free_page((unsigned long)sctns);
 413                         return kvm_s390_inject_prog_cond(vcpu, r);
 414                 }
 415         }
 416
 417         free_page((unsigned long)sctns);
 418         vcpu->run->s.regs.gprs[reg2 + 1] = rc;
 419         kvm_s390_set_psw_cc(vcpu, cc);
 420         return r;
 421 }
 422
 423 static int handle_operexc(struct kvm_vcpu *vcpu)
 424 {
 425         psw_t oldpsw, newpsw;
 426         int rc;
 427
 428         vcpu->stat.exit_operation_exception++;
 429         trace_kvm_s390_handle_operexc(vcpu, vcpu->arch.sie_block->ipa,
 430                                       vcpu->arch.sie_block->ipb);
 431
 432         if (vcpu->arch.sie_block->ipa == 0xb256)
 433                 return handle_sthyi(vcpu);
 434
 435         if (vcpu->arch.sie_block->ipa == 0 && vcpu->kvm->arch.user_instr0)
 436                 return -EOPNOTSUPP;
 437         rc = read_guest_lc(vcpu, __LC_PGM_NEW_PSW, &newpsw, sizeof(psw_t));
 438         if (rc)
 439                 return rc;
 440         /*
 441          * Avoid endless loops of operation exceptions, if the pgm new
 442          * PSW will cause a new operation exception.
 443          * The heuristic checks if the pgm new psw is within 6 bytes before
 444          * the faulting psw address (with same DAT, AS settings) and the
 445          * new psw is not a wait psw and the fault was not triggered by
 446          * problem state.
 447          */
 448         oldpsw = vcpu->arch.sie_block->gpsw;
 449         if (oldpsw.addr - newpsw.addr <= 6 &&
 450             !(newpsw.mask & PSW_MASK_WAIT) &&
 451             !(oldpsw.mask & PSW_MASK_PSTATE) &&
 452             (newpsw.mask & PSW_MASK_ASC) == (oldpsw.mask & PSW_MASK_ASC) &&
 453             (newpsw.mask & PSW_MASK_DAT) == (oldpsw.mask & PSW_MASK_DAT))
 454                 return -EOPNOTSUPP;
 455
 456         return kvm_s390_inject_program_int(vcpu, PGM_OPERATION);
 457 }
 458
 459 int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu)
 460 {
 461         int rc, per_rc = 0;
 462
 463         if (kvm_is_ucontrol(vcpu->kvm))
 464                 return -EOPNOTSUPP;
 465
 466         switch (vcpu->arch.sie_block->icptcode) {
 467         case ICPT_EXTREQ:
 468         case ICPT_IOREQ:
 469                 return handle_noop(vcpu);
 470         case ICPT_INST:
 471                 rc = handle_instruction(vcpu);
 472                 break;
 473         case ICPT_PROGI:
 474                 return handle_prog(vcpu);
 475         case ICPT_EXTINT:
 476                 return handle_external_interrupt(vcpu);
 477         case ICPT_WAIT:
 478                 return kvm_s390_handle_wait(vcpu);
 479         case ICPT_VALIDITY:
 480                 return handle_validity(vcpu);
 481         case ICPT_STOP:
 482                 return handle_stop(vcpu);
 483         case ICPT_OPEREXC:
 484                 rc = handle_operexc(vcpu);
 485                 break;
 486         case ICPT_PARTEXEC:
 487                 rc = handle_partial_execution(vcpu);
 488                 break;
 489         case ICPT_KSS:
 490                 rc = kvm_s390_skey_check_enable(vcpu);
 491                 break;
 492         default:
 493                 return -EOPNOTSUPP;
 494         }
 495
 496         /* process PER, also if the instrution is processed in user space */
 497         if (vcpu->arch.sie_block->icptstatus & 0x02 &&
 498             (!rc || rc == -EOPNOTSUPP))
 499                 per_rc = kvm_s390_handle_per_ifetch_icpt(vcpu);
 500         return per_rc ? per_rc : rc;
 501 }