arch/s390/kvm/intercept.c

   1 /*
   2  * in-kernel handling for sie intercepts
   3  *
   4  * Copyright IBM Corp. 2008, 2009
   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): Carsten Otte <cotte@de.ibm.com>
  11  *               Christian Borntraeger <borntraeger@de.ibm.com>
  12  */
  13
  14 #include <linux/kvm_host.h>
  15 #include <linux/errno.h>
  16 #include <linux/pagemap.h>
  17
  18 #include <asm/kvm_host.h>
  19 #include <asm/asm-offsets.h>
  20
  21 #include "kvm-s390.h"
  22 #include "gaccess.h"
  23 #include "trace.h"
  24 #include "trace-s390.h"
  25
  26
  27 static const intercept_handler_t instruction_handlers[256] = {
  28         [0x01] = kvm_s390_handle_01,
  29         [0x82] = kvm_s390_handle_lpsw,
  30         [0x83] = kvm_s390_handle_diag,
  31         [0xae] = kvm_s390_handle_sigp,
  32         [0xb2] = kvm_s390_handle_b2,
  33         [0xb6] = kvm_s390_handle_stctl,
  34         [0xb7] = kvm_s390_handle_lctl,
  35         [0xb9] = kvm_s390_handle_b9,
  36         [0xe5] = kvm_s390_handle_e5,
  37         [0xeb] = kvm_s390_handle_eb,
  38 };
  39
  40 static int handle_noop(struct kvm_vcpu *vcpu)
  41 {
  42         switch (vcpu->arch.sie_block->icptcode) {
  43         case 0x0:
  44                 vcpu->stat.exit_null++;
  45                 break;
  46         case 0x10:
  47                 vcpu->stat.exit_external_request++;
  48                 break;
  49         case 0x14:
  50                 vcpu->stat.exit_external_interrupt++;
  51                 break;
  52         default:
  53                 break; /* nothing */
  54         }
  55         return 0;
  56 }
  57
  58 static int handle_stop(struct kvm_vcpu *vcpu)
  59 {
  60         int rc = 0;
  61
  62         vcpu->stat.exit_stop_request++;
  63         spin_lock_bh(&vcpu->arch.local_int.lock);
  64
  65         trace_kvm_s390_stop_request(vcpu->arch.local_int.action_bits);
  66
  67         if (vcpu->arch.local_int.action_bits & ACTION_STOP_ON_STOP) {
  68                 atomic_set_mask(CPUSTAT_STOPPED,
  69                                 &vcpu->arch.sie_block->cpuflags);
  70                 vcpu->arch.local_int.action_bits &= ~ACTION_STOP_ON_STOP;
  71                 VCPU_EVENT(vcpu, 3, "%s", "cpu stopped");
  72                 rc = -EOPNOTSUPP;
  73         }
  74
  75         if (vcpu->arch.local_int.action_bits & ACTION_STORE_ON_STOP) {
  76                 vcpu->arch.local_int.action_bits &= ~ACTION_STORE_ON_STOP;
  77                 /* store status must be called unlocked. Since local_int.lock
  78                  * only protects local_int.* and not guest memory we can give
  79                  * up the lock here */
  80                 spin_unlock_bh(&vcpu->arch.local_int.lock);
  81                 rc = kvm_s390_vcpu_store_status(vcpu,
  82                                                 KVM_S390_STORE_STATUS_NOADDR);
  83                 if (rc >= 0)
  84                         rc = -EOPNOTSUPP;
  85         } else
  86                 spin_unlock_bh(&vcpu->arch.local_int.lock);
  87         return rc;
  88 }
  89
  90 static int handle_validity(struct kvm_vcpu *vcpu)
  91 {
  92         int viwhy = vcpu->arch.sie_block->ipb >> 16;
  93
  94         vcpu->stat.exit_validity++;
  95         trace_kvm_s390_intercept_validity(vcpu, viwhy);
  96         WARN_ONCE(true, "kvm: unhandled validity intercept 0x%x\n", viwhy);
  97         return -EOPNOTSUPP;
  98 }
  99
 100 static int handle_instruction(struct kvm_vcpu *vcpu)
 101 {
 102         intercept_handler_t handler;
 103
 104         vcpu->stat.exit_instruction++;
 105         trace_kvm_s390_intercept_instruction(vcpu,
 106                                              vcpu->arch.sie_block->ipa,
 107                                              vcpu->arch.sie_block->ipb);
 108         handler = instruction_handlers[vcpu->arch.sie_block->ipa >> 8];
 109         if (handler)
 110                 return handler(vcpu);
 111         return -EOPNOTSUPP;
 112 }
 113
 114 static void __extract_prog_irq(struct kvm_vcpu *vcpu,
 115                                struct kvm_s390_pgm_info *pgm_info)
 116 {
 117         memset(pgm_info, 0, sizeof(struct kvm_s390_pgm_info));
 118         pgm_info->code = vcpu->arch.sie_block->iprcc;
 119
 120         switch (vcpu->arch.sie_block->iprcc & ~PGM_PER) {
 121         case PGM_AFX_TRANSLATION:
 122         case PGM_ASX_TRANSLATION:
 123         case PGM_EX_TRANSLATION:
 124         case PGM_LFX_TRANSLATION:
 125         case PGM_LSTE_SEQUENCE:
 126         case PGM_LSX_TRANSLATION:
 127         case PGM_LX_TRANSLATION:
 128         case PGM_PRIMARY_AUTHORITY:
 129         case PGM_SECONDARY_AUTHORITY:
 130         case PGM_SPACE_SWITCH:
 131                 pgm_info->trans_exc_code = vcpu->arch.sie_block->tecmc;
 132                 break;
 133         case PGM_ALEN_TRANSLATION:
 134         case PGM_ALE_SEQUENCE:
 135         case PGM_ASTE_INSTANCE:
 136         case PGM_ASTE_SEQUENCE:
 137         case PGM_ASTE_VALIDITY:
 138         case PGM_EXTENDED_AUTHORITY:
 139                 pgm_info->exc_access_id = vcpu->arch.sie_block->eai;
 140                 break;
 141         case PGM_ASCE_TYPE:
 142         case PGM_PAGE_TRANSLATION:
 143         case PGM_REGION_FIRST_TRANS:
 144         case PGM_REGION_SECOND_TRANS:
 145         case PGM_REGION_THIRD_TRANS:
 146         case PGM_SEGMENT_TRANSLATION:
 147                 pgm_info->trans_exc_code = vcpu->arch.sie_block->tecmc;
 148                 pgm_info->exc_access_id  = vcpu->arch.sie_block->eai;
 149                 pgm_info->op_access_id  = vcpu->arch.sie_block->oai;
 150                 break;
 151         case PGM_MONITOR:
 152                 pgm_info->mon_class_nr = vcpu->arch.sie_block->mcn;
 153                 pgm_info->mon_code = vcpu->arch.sie_block->tecmc;
 154                 break;
 155         case PGM_DATA:
 156                 pgm_info->data_exc_code = vcpu->arch.sie_block->dxc;
 157                 break;
 158         case PGM_PROTECTION:
 159                 pgm_info->trans_exc_code = vcpu->arch.sie_block->tecmc;
 160                 pgm_info->exc_access_id  = vcpu->arch.sie_block->eai;
 161                 break;
 162         default:
 163                 break;
 164         }
 165
 166         if (vcpu->arch.sie_block->iprcc & PGM_PER) {
 167                 pgm_info->per_code = vcpu->arch.sie_block->perc;
 168                 pgm_info->per_atmid = vcpu->arch.sie_block->peratmid;
 169                 pgm_info->per_address = vcpu->arch.sie_block->peraddr;
 170                 pgm_info->per_access_id = vcpu->arch.sie_block->peraid;
 171         }
 172 }
 173
 174 /*
 175  * restore ITDB to program-interruption TDB in guest lowcore
 176  * and set TX abort indication if required
 177 */
 178 static int handle_itdb(struct kvm_vcpu *vcpu)
 179 {
 180         struct kvm_s390_itdb *itdb;
 181         int rc;
 182
 183         if (!IS_TE_ENABLED(vcpu) || !IS_ITDB_VALID(vcpu))
 184                 return 0;
 185         if (current->thread.per_flags & PER_FLAG_NO_TE)
 186                 return 0;
 187         itdb = (struct kvm_s390_itdb *)vcpu->arch.sie_block->itdba;
 188         rc = write_guest_lc(vcpu, __LC_PGM_TDB, itdb, sizeof(*itdb));
 189         if (rc)
 190                 return rc;
 191         memset(itdb, 0, sizeof(*itdb));
 192
 193         return 0;
 194 }
 195
 196 #define per_event(vcpu) (vcpu->arch.sie_block->iprcc & PGM_PER)
 197
 198 static int handle_prog(struct kvm_vcpu *vcpu)
 199 {
 200         struct kvm_s390_pgm_info pgm_info;
 201         int rc;
 202
 203         vcpu->stat.exit_program_interruption++;
 204
 205         if (guestdbg_enabled(vcpu) && per_event(vcpu)) {
 206                 kvm_s390_handle_per_event(vcpu);
 207                 /* the interrupt might have been filtered out completely */
 208                 if (vcpu->arch.sie_block->iprcc == 0)
 209                         return 0;
 210         }
 211
 212         trace_kvm_s390_intercept_prog(vcpu, vcpu->arch.sie_block->iprcc);
 213
 214         rc = handle_itdb(vcpu);
 215         if (rc)
 216                 return rc;
 217
 218         __extract_prog_irq(vcpu, &pgm_info);
 219         return kvm_s390_inject_prog_irq(vcpu, &pgm_info);
 220 }
 221
 222 static int handle_instruction_and_prog(struct kvm_vcpu *vcpu)
 223 {
 224         int rc, rc2;
 225
 226         vcpu->stat.exit_instr_and_program++;
 227         rc = handle_instruction(vcpu);
 228         rc2 = handle_prog(vcpu);
 229
 230         if (rc == -EOPNOTSUPP)
 231                 vcpu->arch.sie_block->icptcode = 0x04;
 232         if (rc)
 233                 return rc;
 234         return rc2;
 235 }
 236
 237 static const intercept_handler_t intercept_funcs[] = {
 238         [0x00 >> 2] = handle_noop,
 239         [0x04 >> 2] = handle_instruction,
 240         [0x08 >> 2] = handle_prog,
 241         [0x0C >> 2] = handle_instruction_and_prog,
 242         [0x10 >> 2] = handle_noop,
 243         [0x14 >> 2] = handle_noop,
 244         [0x18 >> 2] = handle_noop,
 245         [0x1C >> 2] = kvm_s390_handle_wait,
 246         [0x20 >> 2] = handle_validity,
 247         [0x28 >> 2] = handle_stop,
 248 };
 249
 250 int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu)
 251 {
 252         intercept_handler_t func;
 253         u8 code = vcpu->arch.sie_block->icptcode;
 254
 255         if (code & 3 || (code >> 2) >= ARRAY_SIZE(intercept_funcs))
 256                 return -EOPNOTSUPP;
 257         func = intercept_funcs[code >> 2];
 258         if (func)
 259                 return func(vcpu);
 260         return -EOPNOTSUPP;
 261 }