arch/s390/kvm/sigp.c

   1 /*
   2  * handling interprocessor communication
   3  *
   4  * Copyright IBM Corp. 2008, 2013
   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  *               Christian Ehrhardt <ehrhardt@de.ibm.com>
  13  */
  14
  15 #include <linux/kvm.h>
  16 #include <linux/kvm_host.h>
  17 #include <linux/slab.h>
  18 #include <asm/sigp.h>
  19 #include "gaccess.h"
  20 #include "kvm-s390.h"
  21 #include "trace.h"
  22
  23 static int __sigp_sense(struct kvm_vcpu *vcpu, u16 cpu_addr,
  24                         u64 *reg)
  25 {
  26         struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
  27         int rc;
  28
  29         if (cpu_addr >= KVM_MAX_VCPUS)
  30                 return SIGP_CC_NOT_OPERATIONAL;
  31
  32         spin_lock(&fi->lock);
  33         if (fi->local_int[cpu_addr] == NULL)
  34                 rc = SIGP_CC_NOT_OPERATIONAL;
  35         else if (!(atomic_read(fi->local_int[cpu_addr]->cpuflags)
  36                    & (CPUSTAT_ECALL_PEND | CPUSTAT_STOPPED)))
  37                 rc = SIGP_CC_ORDER_CODE_ACCEPTED;
  38         else {
  39                 *reg &= 0xffffffff00000000UL;
  40                 if (atomic_read(fi->local_int[cpu_addr]->cpuflags)
  41                     & CPUSTAT_ECALL_PEND)
  42                         *reg |= SIGP_STATUS_EXT_CALL_PENDING;
  43                 if (atomic_read(fi->local_int[cpu_addr]->cpuflags)
  44                     & CPUSTAT_STOPPED)
  45                         *reg |= SIGP_STATUS_STOPPED;
  46                 rc = SIGP_CC_STATUS_STORED;
  47         }
  48         spin_unlock(&fi->lock);
  49
  50         VCPU_EVENT(vcpu, 4, "sensed status of cpu %x rc %x", cpu_addr, rc);
  51         return rc;
  52 }
  53
  54 static int __sigp_emergency(struct kvm_vcpu *vcpu, u16 cpu_addr)
  55 {
  56         struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
  57         struct kvm_s390_local_interrupt *li;
  58         struct kvm_s390_interrupt_info *inti;
  59         int rc;
  60
  61         if (cpu_addr >= KVM_MAX_VCPUS)
  62                 return SIGP_CC_NOT_OPERATIONAL;
  63
  64         inti = kzalloc(sizeof(*inti), GFP_KERNEL);
  65         if (!inti)
  66                 return -ENOMEM;
  67
  68         inti->type = KVM_S390_INT_EMERGENCY;
  69         inti->emerg.code = vcpu->vcpu_id;
  70
  71         spin_lock(&fi->lock);
  72         li = fi->local_int[cpu_addr];
  73         if (li == NULL) {
  74                 rc = SIGP_CC_NOT_OPERATIONAL;
  75                 kfree(inti);
  76                 goto unlock;
  77         }
  78         spin_lock_bh(&li->lock);
  79         list_add_tail(&inti->list, &li->list);
  80         atomic_set(&li->active, 1);
  81         atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
  82         if (waitqueue_active(li->wq))
  83                 wake_up_interruptible(li->wq);
  84         spin_unlock_bh(&li->lock);
  85         rc = SIGP_CC_ORDER_CODE_ACCEPTED;
  86         VCPU_EVENT(vcpu, 4, "sent sigp emerg to cpu %x", cpu_addr);
  87 unlock:
  88         spin_unlock(&fi->lock);
  89         return rc;
  90 }
  91
  92 static int __sigp_conditional_emergency(struct kvm_vcpu *vcpu, u16 cpu_addr,
  93                                         u16 asn, u64 *reg)
  94 {
  95         struct kvm_vcpu *dst_vcpu = NULL;
  96         const u64 psw_int_mask = PSW_MASK_IO | PSW_MASK_EXT;
  97         u16 p_asn, s_asn;
  98         psw_t *psw;
  99         u32 flags;
 100
 101         if (cpu_addr < KVM_MAX_VCPUS)
 102                 dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_addr);
 103         if (!dst_vcpu)
 104                 return SIGP_CC_NOT_OPERATIONAL;
 105         flags = atomic_read(&dst_vcpu->arch.sie_block->cpuflags);
 106         psw = &dst_vcpu->arch.sie_block->gpsw;
 107         p_asn = dst_vcpu->arch.sie_block->gcr[4] & 0xffff;  /* Primary ASN */
 108         s_asn = dst_vcpu->arch.sie_block->gcr[3] & 0xffff;  /* Secondary ASN */
 109
 110         /* Deliver the emergency signal? */
 111         if (!(flags & CPUSTAT_STOPPED)
 112             || (psw->mask & psw_int_mask) != psw_int_mask
 113             || ((flags & CPUSTAT_WAIT) && psw->addr != 0)
 114             || (!(flags & CPUSTAT_WAIT) && (asn == p_asn || asn == s_asn))) {
 115                 return __sigp_emergency(vcpu, cpu_addr);
 116         } else {
 117                 *reg &= 0xffffffff00000000UL;
 118                 *reg |= SIGP_STATUS_INCORRECT_STATE;
 119                 return SIGP_CC_STATUS_STORED;
 120         }
 121 }
 122
 123 static int __sigp_external_call(struct kvm_vcpu *vcpu, u16 cpu_addr)
 124 {
 125         struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
 126         struct kvm_s390_local_interrupt *li;
 127         struct kvm_s390_interrupt_info *inti;
 128         int rc;
 129
 130         if (cpu_addr >= KVM_MAX_VCPUS)
 131                 return SIGP_CC_NOT_OPERATIONAL;
 132
 133         inti = kzalloc(sizeof(*inti), GFP_KERNEL);
 134         if (!inti)
 135                 return -ENOMEM;
 136
 137         inti->type = KVM_S390_INT_EXTERNAL_CALL;
 138         inti->extcall.code = vcpu->vcpu_id;
 139
 140         spin_lock(&fi->lock);
 141         li = fi->local_int[cpu_addr];
 142         if (li == NULL) {
 143                 rc = SIGP_CC_NOT_OPERATIONAL;
 144                 kfree(inti);
 145                 goto unlock;
 146         }
 147         spin_lock_bh(&li->lock);
 148         list_add_tail(&inti->list, &li->list);
 149         atomic_set(&li->active, 1);
 150         atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
 151         if (waitqueue_active(li->wq))
 152                 wake_up_interruptible(li->wq);
 153         spin_unlock_bh(&li->lock);
 154         rc = SIGP_CC_ORDER_CODE_ACCEPTED;
 155         VCPU_EVENT(vcpu, 4, "sent sigp ext call to cpu %x", cpu_addr);
 156 unlock:
 157         spin_unlock(&fi->lock);
 158         return rc;
 159 }
 160
 161 static int __inject_sigp_stop(struct kvm_s390_local_interrupt *li, int action)
 162 {
 163         struct kvm_s390_interrupt_info *inti;
 164         int rc = SIGP_CC_ORDER_CODE_ACCEPTED;
 165
 166         inti = kzalloc(sizeof(*inti), GFP_ATOMIC);
 167         if (!inti)
 168                 return -ENOMEM;
 169         inti->type = KVM_S390_SIGP_STOP;
 170
 171         spin_lock_bh(&li->lock);
 172         if ((atomic_read(li->cpuflags) & CPUSTAT_STOPPED)) {
 173                 kfree(inti);
 174                 if ((action & ACTION_STORE_ON_STOP) != 0)
 175                         rc = -ESHUTDOWN;
 176                 goto out;
 177         }
 178         list_add_tail(&inti->list, &li->list);
 179         atomic_set(&li->active, 1);
 180         atomic_set_mask(CPUSTAT_STOP_INT, li->cpuflags);
 181         li->action_bits |= action;
 182         if (waitqueue_active(li->wq))
 183                 wake_up_interruptible(li->wq);
 184 out:
 185         spin_unlock_bh(&li->lock);
 186
 187         return rc;
 188 }
 189
 190 static int __sigp_stop(struct kvm_vcpu *vcpu, u16 cpu_addr, int action)
 191 {
 192         struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
 193         struct kvm_s390_local_interrupt *li;
 194         int rc;
 195
 196         if (cpu_addr >= KVM_MAX_VCPUS)
 197                 return SIGP_CC_NOT_OPERATIONAL;
 198
 199         spin_lock(&fi->lock);
 200         li = fi->local_int[cpu_addr];
 201         if (li == NULL) {
 202                 rc = SIGP_CC_NOT_OPERATIONAL;
 203                 goto unlock;
 204         }
 205
 206         rc = __inject_sigp_stop(li, action);
 207
 208 unlock:
 209         spin_unlock(&fi->lock);
 210         VCPU_EVENT(vcpu, 4, "sent sigp stop to cpu %x", cpu_addr);
 211
 212         if ((action & ACTION_STORE_ON_STOP) != 0 && rc == -ESHUTDOWN) {
 213                 /* If the CPU has already been stopped, we still have
 214                  * to save the status when doing stop-and-store. This
 215                  * has to be done after unlocking all spinlocks. */
 216                 struct kvm_vcpu *dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_addr);
 217                 rc = kvm_s390_store_status_unloaded(dst_vcpu,
 218                                                 KVM_S390_STORE_STATUS_NOADDR);
 219         }
 220
 221         return rc;
 222 }
 223
 224 static int __sigp_set_arch(struct kvm_vcpu *vcpu, u32 parameter)
 225 {
 226         int rc;
 227
 228         switch (parameter & 0xff) {
 229         case 0:
 230                 rc = SIGP_CC_NOT_OPERATIONAL;
 231                 break;
 232         case 1:
 233         case 2:
 234                 rc = SIGP_CC_ORDER_CODE_ACCEPTED;
 235                 break;
 236         default:
 237                 rc = -EOPNOTSUPP;
 238         }
 239         return rc;
 240 }
 241
 242 static int __sigp_set_prefix(struct kvm_vcpu *vcpu, u16 cpu_addr, u32 address,
 243                              u64 *reg)
 244 {
 245         struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
 246         struct kvm_s390_local_interrupt *li = NULL;
 247         struct kvm_s390_interrupt_info *inti;
 248         int rc;
 249         u8 tmp;
 250
 251         /* make sure that the new value is valid memory */
 252         address = address & 0x7fffe000u;
 253         if (copy_from_guest_absolute(vcpu, &tmp, address, 1) ||
 254            copy_from_guest_absolute(vcpu, &tmp, address + PAGE_SIZE, 1)) {
 255                 *reg &= 0xffffffff00000000UL;
 256                 *reg |= SIGP_STATUS_INVALID_PARAMETER;
 257                 return SIGP_CC_STATUS_STORED;
 258         }
 259
 260         inti = kzalloc(sizeof(*inti), GFP_KERNEL);
 261         if (!inti)
 262                 return SIGP_CC_BUSY;
 263
 264         spin_lock(&fi->lock);
 265         if (cpu_addr < KVM_MAX_VCPUS)
 266                 li = fi->local_int[cpu_addr];
 267
 268         if (li == NULL) {
 269                 *reg &= 0xffffffff00000000UL;
 270                 *reg |= SIGP_STATUS_INCORRECT_STATE;
 271                 rc = SIGP_CC_STATUS_STORED;
 272                 kfree(inti);
 273                 goto out_fi;
 274         }
 275
 276         spin_lock_bh(&li->lock);
 277         /* cpu must be in stopped state */
 278         if (!(atomic_read(li->cpuflags) & CPUSTAT_STOPPED)) {
 279                 *reg &= 0xffffffff00000000UL;
 280                 *reg |= SIGP_STATUS_INCORRECT_STATE;
 281                 rc = SIGP_CC_STATUS_STORED;
 282                 kfree(inti);
 283                 goto out_li;
 284         }
 285
 286         inti->type = KVM_S390_SIGP_SET_PREFIX;
 287         inti->prefix.address = address;
 288
 289         list_add_tail(&inti->list, &li->list);
 290         atomic_set(&li->active, 1);
 291         if (waitqueue_active(li->wq))
 292                 wake_up_interruptible(li->wq);
 293         rc = SIGP_CC_ORDER_CODE_ACCEPTED;
 294
 295         VCPU_EVENT(vcpu, 4, "set prefix of cpu %02x to %x", cpu_addr, address);
 296 out_li:
 297         spin_unlock_bh(&li->lock);
 298 out_fi:
 299         spin_unlock(&fi->lock);
 300         return rc;
 301 }
 302
 303 static int __sigp_store_status_at_addr(struct kvm_vcpu *vcpu, u16 cpu_id,
 304                                         u32 addr, u64 *reg)
 305 {
 306         struct kvm_vcpu *dst_vcpu = NULL;
 307         int flags;
 308         int rc;
 309
 310         if (cpu_id < KVM_MAX_VCPUS)
 311                 dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_id);
 312         if (!dst_vcpu)
 313                 return SIGP_CC_NOT_OPERATIONAL;
 314
 315         spin_lock_bh(&dst_vcpu->arch.local_int.lock);
 316         flags = atomic_read(dst_vcpu->arch.local_int.cpuflags);
 317         spin_unlock_bh(&dst_vcpu->arch.local_int.lock);
 318         if (!(flags & CPUSTAT_STOPPED)) {
 319                 *reg &= 0xffffffff00000000UL;
 320                 *reg |= SIGP_STATUS_INCORRECT_STATE;
 321                 return SIGP_CC_STATUS_STORED;
 322         }
 323
 324         addr &= 0x7ffffe00;
 325         rc = kvm_s390_store_status_unloaded(dst_vcpu, addr);
 326         if (rc == -EFAULT) {
 327                 *reg &= 0xffffffff00000000UL;
 328                 *reg |= SIGP_STATUS_INVALID_PARAMETER;
 329                 rc = SIGP_CC_STATUS_STORED;
 330         }
 331         return rc;
 332 }
 333
 334 static int __sigp_sense_running(struct kvm_vcpu *vcpu, u16 cpu_addr,
 335                                 u64 *reg)
 336 {
 337         int rc;
 338         struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
 339
 340         if (cpu_addr >= KVM_MAX_VCPUS)
 341                 return SIGP_CC_NOT_OPERATIONAL;
 342
 343         spin_lock(&fi->lock);
 344         if (fi->local_int[cpu_addr] == NULL)
 345                 rc = SIGP_CC_NOT_OPERATIONAL;
 346         else {
 347                 if (atomic_read(fi->local_int[cpu_addr]->cpuflags)
 348                     & CPUSTAT_RUNNING) {
 349                         /* running */
 350                         rc = SIGP_CC_ORDER_CODE_ACCEPTED;
 351                 } else {
 352                         /* not running */
 353                         *reg &= 0xffffffff00000000UL;
 354                         *reg |= SIGP_STATUS_NOT_RUNNING;
 355                         rc = SIGP_CC_STATUS_STORED;
 356                 }
 357         }
 358         spin_unlock(&fi->lock);
 359
 360         VCPU_EVENT(vcpu, 4, "sensed running status of cpu %x rc %x", cpu_addr,
 361                    rc);
 362
 363         return rc;
 364 }
 365
 366 /* Test whether the destination CPU is available and not busy */
 367 static int sigp_check_callable(struct kvm_vcpu *vcpu, u16 cpu_addr)
 368 {
 369         struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
 370         struct kvm_s390_local_interrupt *li;
 371         int rc = SIGP_CC_ORDER_CODE_ACCEPTED;
 372
 373         if (cpu_addr >= KVM_MAX_VCPUS)
 374                 return SIGP_CC_NOT_OPERATIONAL;
 375
 376         spin_lock(&fi->lock);
 377         li = fi->local_int[cpu_addr];
 378         if (li == NULL) {
 379                 rc = SIGP_CC_NOT_OPERATIONAL;
 380                 goto out;
 381         }
 382
 383         spin_lock_bh(&li->lock);
 384         if (li->action_bits & ACTION_STOP_ON_STOP)
 385                 rc = SIGP_CC_BUSY;
 386         spin_unlock_bh(&li->lock);
 387 out:
 388         spin_unlock(&fi->lock);
 389         return rc;
 390 }
 391
 392 int kvm_s390_handle_sigp(struct kvm_vcpu *vcpu)
 393 {
 394         int r1 = (vcpu->arch.sie_block->ipa & 0x00f0) >> 4;
 395         int r3 = vcpu->arch.sie_block->ipa & 0x000f;
 396         u32 parameter;
 397         u16 cpu_addr = vcpu->run->s.regs.gprs[r3];
 398         u8 order_code;
 399         int rc;
 400
 401         /* sigp in userspace can exit */
 402         if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
 403                 return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
 404
 405         order_code = kvm_s390_get_base_disp_rs(vcpu);
 406
 407         if (r1 % 2)
 408                 parameter = vcpu->run->s.regs.gprs[r1];
 409         else
 410                 parameter = vcpu->run->s.regs.gprs[r1 + 1];
 411
 412         trace_kvm_s390_handle_sigp(vcpu, order_code, cpu_addr, parameter);
 413         switch (order_code) {
 414         case SIGP_SENSE:
 415                 vcpu->stat.instruction_sigp_sense++;
 416                 rc = __sigp_sense(vcpu, cpu_addr,
 417                                   &vcpu->run->s.regs.gprs[r1]);
 418                 break;
 419         case SIGP_EXTERNAL_CALL:
 420                 vcpu->stat.instruction_sigp_external_call++;
 421                 rc = __sigp_external_call(vcpu, cpu_addr);
 422                 break;
 423         case SIGP_EMERGENCY_SIGNAL:
 424                 vcpu->stat.instruction_sigp_emergency++;
 425                 rc = __sigp_emergency(vcpu, cpu_addr);
 426                 break;
 427         case SIGP_STOP:
 428                 vcpu->stat.instruction_sigp_stop++;
 429                 rc = __sigp_stop(vcpu, cpu_addr, ACTION_STOP_ON_STOP);
 430                 break;
 431         case SIGP_STOP_AND_STORE_STATUS:
 432                 vcpu->stat.instruction_sigp_stop++;
 433                 rc = __sigp_stop(vcpu, cpu_addr, ACTION_STORE_ON_STOP |
 434                                                  ACTION_STOP_ON_STOP);
 435                 break;
 436         case SIGP_STORE_STATUS_AT_ADDRESS:
 437                 rc = __sigp_store_status_at_addr(vcpu, cpu_addr, parameter,
 438                                                  &vcpu->run->s.regs.gprs[r1]);
 439                 break;
 440         case SIGP_SET_ARCHITECTURE:
 441                 vcpu->stat.instruction_sigp_arch++;
 442                 rc = __sigp_set_arch(vcpu, parameter);
 443                 break;
 444         case SIGP_SET_PREFIX:
 445                 vcpu->stat.instruction_sigp_prefix++;
 446                 rc = __sigp_set_prefix(vcpu, cpu_addr, parameter,
 447                                        &vcpu->run->s.regs.gprs[r1]);
 448                 break;
 449         case SIGP_COND_EMERGENCY_SIGNAL:
 450                 rc = __sigp_conditional_emergency(vcpu, cpu_addr, parameter,
 451                                                   &vcpu->run->s.regs.gprs[r1]);
 452                 break;
 453         case SIGP_SENSE_RUNNING:
 454                 vcpu->stat.instruction_sigp_sense_running++;
 455                 rc = __sigp_sense_running(vcpu, cpu_addr,
 456                                           &vcpu->run->s.regs.gprs[r1]);
 457                 break;
 458         case SIGP_START:
 459                 rc = sigp_check_callable(vcpu, cpu_addr);
 460                 if (rc == SIGP_CC_ORDER_CODE_ACCEPTED)
 461                         rc = -EOPNOTSUPP;    /* Handle START in user space */
 462                 break;
 463         case SIGP_RESTART:
 464                 vcpu->stat.instruction_sigp_restart++;
 465                 rc = sigp_check_callable(vcpu, cpu_addr);
 466                 if (rc == SIGP_CC_ORDER_CODE_ACCEPTED) {
 467                         VCPU_EVENT(vcpu, 4,
 468                                    "sigp restart %x to handle userspace",
 469                                    cpu_addr);
 470                         /* user space must know about restart */
 471                         rc = -EOPNOTSUPP;
 472                 }
 473                 break;
 474         default:
 475                 return -EOPNOTSUPP;
 476         }
 477
 478         if (rc < 0)
 479                 return rc;
 480
 481         kvm_s390_set_psw_cc(vcpu, rc);
 482         return 0;
 483 }