arch/s390/kvm/sigp.c

   1 /*
   2  * handling interprocessor communication
   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  *               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_external_call(struct kvm_vcpu *vcpu, u16 cpu_addr)
  93 {
  94         struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
  95         struct kvm_s390_local_interrupt *li;
  96         struct kvm_s390_interrupt_info *inti;
  97         int rc;
  98
  99         if (cpu_addr >= KVM_MAX_VCPUS)
 100                 return SIGP_CC_NOT_OPERATIONAL;
 101
 102         inti = kzalloc(sizeof(*inti), GFP_KERNEL);
 103         if (!inti)
 104                 return -ENOMEM;
 105
 106         inti->type = KVM_S390_INT_EXTERNAL_CALL;
 107         inti->extcall.code = vcpu->vcpu_id;
 108
 109         spin_lock(&fi->lock);
 110         li = fi->local_int[cpu_addr];
 111         if (li == NULL) {
 112                 rc = SIGP_CC_NOT_OPERATIONAL;
 113                 kfree(inti);
 114                 goto unlock;
 115         }
 116         spin_lock_bh(&li->lock);
 117         list_add_tail(&inti->list, &li->list);
 118         atomic_set(&li->active, 1);
 119         atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags);
 120         if (waitqueue_active(li->wq))
 121                 wake_up_interruptible(li->wq);
 122         spin_unlock_bh(&li->lock);
 123         rc = SIGP_CC_ORDER_CODE_ACCEPTED;
 124         VCPU_EVENT(vcpu, 4, "sent sigp ext call to cpu %x", cpu_addr);
 125 unlock:
 126         spin_unlock(&fi->lock);
 127         return rc;
 128 }
 129
 130 static int __inject_sigp_stop(struct kvm_s390_local_interrupt *li, int action)
 131 {
 132         struct kvm_s390_interrupt_info *inti;
 133         int rc = SIGP_CC_ORDER_CODE_ACCEPTED;
 134
 135         inti = kzalloc(sizeof(*inti), GFP_ATOMIC);
 136         if (!inti)
 137                 return -ENOMEM;
 138         inti->type = KVM_S390_SIGP_STOP;
 139
 140         spin_lock_bh(&li->lock);
 141         if ((atomic_read(li->cpuflags) & CPUSTAT_STOPPED)) {
 142                 kfree(inti);
 143                 if ((action & ACTION_STORE_ON_STOP) != 0)
 144                         rc = -ESHUTDOWN;
 145                 goto out;
 146         }
 147         list_add_tail(&inti->list, &li->list);
 148         atomic_set(&li->active, 1);
 149         atomic_set_mask(CPUSTAT_STOP_INT, li->cpuflags);
 150         li->action_bits |= action;
 151         if (waitqueue_active(li->wq))
 152                 wake_up_interruptible(li->wq);
 153 out:
 154         spin_unlock_bh(&li->lock);
 155
 156         return rc;
 157 }
 158
 159 static int __sigp_stop(struct kvm_vcpu *vcpu, u16 cpu_addr, int action)
 160 {
 161         struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
 162         struct kvm_s390_local_interrupt *li;
 163         int rc;
 164
 165         if (cpu_addr >= KVM_MAX_VCPUS)
 166                 return SIGP_CC_NOT_OPERATIONAL;
 167
 168         spin_lock(&fi->lock);
 169         li = fi->local_int[cpu_addr];
 170         if (li == NULL) {
 171                 rc = SIGP_CC_NOT_OPERATIONAL;
 172                 goto unlock;
 173         }
 174
 175         rc = __inject_sigp_stop(li, action);
 176
 177 unlock:
 178         spin_unlock(&fi->lock);
 179         VCPU_EVENT(vcpu, 4, "sent sigp stop to cpu %x", cpu_addr);
 180
 181         if ((action & ACTION_STORE_ON_STOP) != 0 && rc == -ESHUTDOWN) {
 182                 /* If the CPU has already been stopped, we still have
 183                  * to save the status when doing stop-and-store. This
 184                  * has to be done after unlocking all spinlocks. */
 185                 struct kvm_vcpu *dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_addr);
 186                 rc = kvm_s390_store_status_unloaded(dst_vcpu,
 187                                                 KVM_S390_STORE_STATUS_NOADDR);
 188         }
 189
 190         return rc;
 191 }
 192
 193 static int __sigp_set_arch(struct kvm_vcpu *vcpu, u32 parameter)
 194 {
 195         int rc;
 196
 197         switch (parameter & 0xff) {
 198         case 0:
 199                 rc = SIGP_CC_NOT_OPERATIONAL;
 200                 break;
 201         case 1:
 202         case 2:
 203                 rc = SIGP_CC_ORDER_CODE_ACCEPTED;
 204                 break;
 205         default:
 206                 rc = -EOPNOTSUPP;
 207         }
 208         return rc;
 209 }
 210
 211 static int __sigp_set_prefix(struct kvm_vcpu *vcpu, u16 cpu_addr, u32 address,
 212                              u64 *reg)
 213 {
 214         struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
 215         struct kvm_s390_local_interrupt *li = NULL;
 216         struct kvm_s390_interrupt_info *inti;
 217         int rc;
 218         u8 tmp;
 219
 220         /* make sure that the new value is valid memory */
 221         address = address & 0x7fffe000u;
 222         if (copy_from_guest_absolute(vcpu, &tmp, address, 1) ||
 223            copy_from_guest_absolute(vcpu, &tmp, address + PAGE_SIZE, 1)) {
 224                 *reg &= 0xffffffff00000000UL;
 225                 *reg |= SIGP_STATUS_INVALID_PARAMETER;
 226                 return SIGP_CC_STATUS_STORED;
 227         }
 228
 229         inti = kzalloc(sizeof(*inti), GFP_KERNEL);
 230         if (!inti)
 231                 return SIGP_CC_BUSY;
 232
 233         spin_lock(&fi->lock);
 234         if (cpu_addr < KVM_MAX_VCPUS)
 235                 li = fi->local_int[cpu_addr];
 236
 237         if (li == NULL) {
 238                 *reg &= 0xffffffff00000000UL;
 239                 *reg |= SIGP_STATUS_INCORRECT_STATE;
 240                 rc = SIGP_CC_STATUS_STORED;
 241                 kfree(inti);
 242                 goto out_fi;
 243         }
 244
 245         spin_lock_bh(&li->lock);
 246         /* cpu must be in stopped state */
 247         if (!(atomic_read(li->cpuflags) & CPUSTAT_STOPPED)) {
 248                 *reg &= 0xffffffff00000000UL;
 249                 *reg |= SIGP_STATUS_INCORRECT_STATE;
 250                 rc = SIGP_CC_STATUS_STORED;
 251                 kfree(inti);
 252                 goto out_li;
 253         }
 254
 255         inti->type = KVM_S390_SIGP_SET_PREFIX;
 256         inti->prefix.address = address;
 257
 258         list_add_tail(&inti->list, &li->list);
 259         atomic_set(&li->active, 1);
 260         if (waitqueue_active(li->wq))
 261                 wake_up_interruptible(li->wq);
 262         rc = SIGP_CC_ORDER_CODE_ACCEPTED;
 263
 264         VCPU_EVENT(vcpu, 4, "set prefix of cpu %02x to %x", cpu_addr, address);
 265 out_li:
 266         spin_unlock_bh(&li->lock);
 267 out_fi:
 268         spin_unlock(&fi->lock);
 269         return rc;
 270 }
 271
 272 static int __sigp_store_status_at_addr(struct kvm_vcpu *vcpu, u16 cpu_id,
 273                                         u32 addr, u64 *reg)
 274 {
 275         struct kvm_vcpu *dst_vcpu = NULL;
 276         int flags;
 277         int rc;
 278
 279         if (cpu_id < KVM_MAX_VCPUS)
 280                 dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_id);
 281         if (!dst_vcpu)
 282                 return SIGP_CC_NOT_OPERATIONAL;
 283
 284         spin_lock_bh(&dst_vcpu->arch.local_int.lock);
 285         flags = atomic_read(dst_vcpu->arch.local_int.cpuflags);
 286         spin_unlock_bh(&dst_vcpu->arch.local_int.lock);
 287         if (!(flags & CPUSTAT_STOPPED)) {
 288                 *reg &= 0xffffffff00000000UL;
 289                 *reg |= SIGP_STATUS_INCORRECT_STATE;
 290                 return SIGP_CC_STATUS_STORED;
 291         }
 292
 293         addr &= 0x7ffffe00;
 294         rc = kvm_s390_store_status_unloaded(dst_vcpu, addr);
 295         if (rc == -EFAULT) {
 296                 *reg &= 0xffffffff00000000UL;
 297                 *reg |= SIGP_STATUS_INVALID_PARAMETER;
 298                 rc = SIGP_CC_STATUS_STORED;
 299         }
 300         return rc;
 301 }
 302
 303 static int __sigp_sense_running(struct kvm_vcpu *vcpu, u16 cpu_addr,
 304                                 u64 *reg)
 305 {
 306         int rc;
 307         struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
 308
 309         if (cpu_addr >= KVM_MAX_VCPUS)
 310                 return SIGP_CC_NOT_OPERATIONAL;
 311
 312         spin_lock(&fi->lock);
 313         if (fi->local_int[cpu_addr] == NULL)
 314                 rc = SIGP_CC_NOT_OPERATIONAL;
 315         else {
 316                 if (atomic_read(fi->local_int[cpu_addr]->cpuflags)
 317                     & CPUSTAT_RUNNING) {
 318                         /* running */
 319                         rc = SIGP_CC_ORDER_CODE_ACCEPTED;
 320                 } else {
 321                         /* not running */
 322                         *reg &= 0xffffffff00000000UL;
 323                         *reg |= SIGP_STATUS_NOT_RUNNING;
 324                         rc = SIGP_CC_STATUS_STORED;
 325                 }
 326         }
 327         spin_unlock(&fi->lock);
 328
 329         VCPU_EVENT(vcpu, 4, "sensed running status of cpu %x rc %x", cpu_addr,
 330                    rc);
 331
 332         return rc;
 333 }
 334
 335 static int __sigp_restart(struct kvm_vcpu *vcpu, u16 cpu_addr)
 336 {
 337         struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
 338         struct kvm_s390_local_interrupt *li;
 339         int rc = SIGP_CC_ORDER_CODE_ACCEPTED;
 340
 341         if (cpu_addr >= KVM_MAX_VCPUS)
 342                 return SIGP_CC_NOT_OPERATIONAL;
 343
 344         spin_lock(&fi->lock);
 345         li = fi->local_int[cpu_addr];
 346         if (li == NULL) {
 347                 rc = SIGP_CC_NOT_OPERATIONAL;
 348                 goto out;
 349         }
 350
 351         spin_lock_bh(&li->lock);
 352         if (li->action_bits & ACTION_STOP_ON_STOP)
 353                 rc = SIGP_CC_BUSY;
 354         else
 355                 VCPU_EVENT(vcpu, 4, "sigp restart %x to handle userspace",
 356                         cpu_addr);
 357         spin_unlock_bh(&li->lock);
 358 out:
 359         spin_unlock(&fi->lock);
 360         return rc;
 361 }
 362
 363 int kvm_s390_handle_sigp(struct kvm_vcpu *vcpu)
 364 {
 365         int r1 = (vcpu->arch.sie_block->ipa & 0x00f0) >> 4;
 366         int r3 = vcpu->arch.sie_block->ipa & 0x000f;
 367         u32 parameter;
 368         u16 cpu_addr = vcpu->run->s.regs.gprs[r3];
 369         u8 order_code;
 370         int rc;
 371
 372         /* sigp in userspace can exit */
 373         if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
 374                 return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
 375
 376         order_code = kvm_s390_get_base_disp_rs(vcpu);
 377
 378         if (r1 % 2)
 379                 parameter = vcpu->run->s.regs.gprs[r1];
 380         else
 381                 parameter = vcpu->run->s.regs.gprs[r1 + 1];
 382
 383         trace_kvm_s390_handle_sigp(vcpu, order_code, cpu_addr, parameter);
 384         switch (order_code) {
 385         case SIGP_SENSE:
 386                 vcpu->stat.instruction_sigp_sense++;
 387                 rc = __sigp_sense(vcpu, cpu_addr,
 388                                   &vcpu->run->s.regs.gprs[r1]);
 389                 break;
 390         case SIGP_EXTERNAL_CALL:
 391                 vcpu->stat.instruction_sigp_external_call++;
 392                 rc = __sigp_external_call(vcpu, cpu_addr);
 393                 break;
 394         case SIGP_EMERGENCY_SIGNAL:
 395                 vcpu->stat.instruction_sigp_emergency++;
 396                 rc = __sigp_emergency(vcpu, cpu_addr);
 397                 break;
 398         case SIGP_STOP:
 399                 vcpu->stat.instruction_sigp_stop++;
 400                 rc = __sigp_stop(vcpu, cpu_addr, ACTION_STOP_ON_STOP);
 401                 break;
 402         case SIGP_STOP_AND_STORE_STATUS:
 403                 vcpu->stat.instruction_sigp_stop++;
 404                 rc = __sigp_stop(vcpu, cpu_addr, ACTION_STORE_ON_STOP |
 405                                                  ACTION_STOP_ON_STOP);
 406                 break;
 407         case SIGP_STORE_STATUS_AT_ADDRESS:
 408                 rc = __sigp_store_status_at_addr(vcpu, cpu_addr, parameter,
 409                                                  &vcpu->run->s.regs.gprs[r1]);
 410                 break;
 411         case SIGP_SET_ARCHITECTURE:
 412                 vcpu->stat.instruction_sigp_arch++;
 413                 rc = __sigp_set_arch(vcpu, parameter);
 414                 break;
 415         case SIGP_SET_PREFIX:
 416                 vcpu->stat.instruction_sigp_prefix++;
 417                 rc = __sigp_set_prefix(vcpu, cpu_addr, parameter,
 418                                        &vcpu->run->s.regs.gprs[r1]);
 419                 break;
 420         case SIGP_SENSE_RUNNING:
 421                 vcpu->stat.instruction_sigp_sense_running++;
 422                 rc = __sigp_sense_running(vcpu, cpu_addr,
 423                                           &vcpu->run->s.regs.gprs[r1]);
 424                 break;
 425         case SIGP_RESTART:
 426                 vcpu->stat.instruction_sigp_restart++;
 427                 rc = __sigp_restart(vcpu, cpu_addr);
 428                 if (rc == SIGP_CC_BUSY)
 429                         break;
 430                 /* user space must know about restart */
 431         default:
 432                 return -EOPNOTSUPP;
 433         }
 434
 435         if (rc < 0)
 436                 return rc;
 437
 438         kvm_s390_set_psw_cc(vcpu, rc);
 439         return 0;
 440 }