Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging

[qemu.git] / target-s390x / kvm.c

diff --git a/target-s390x/kvm.c b/target-s390x/kvm.c
index a444f6999b576bd65f16b3895612b6b8c17ffdb2..56b9af75054e15385d9a4618433f57c968a67a7b 100644 (file)
--- a/target-s390x/kvm.c
+++ b/target-s390x/kvm.c
@@ -53,25 +53,28 @@
 #define IPA0_B9                         0xb900
 #define IPA0_EB                         0xeb00
 
 #define IPA0_B9                         0xb900
 #define IPA0_EB                         0xeb00
 

-#define PRIV_SCLP_CALL                  0x20
-#define PRIV_CSCH                       0x30
-#define PRIV_HSCH                       0x31
-#define PRIV_MSCH                       0x32
-#define PRIV_SSCH                       0x33
-#define PRIV_STSCH                      0x34
-#define PRIV_TSCH                       0x35
-#define PRIV_TPI                        0x36
-#define PRIV_SAL                        0x37
-#define PRIV_RSCH                       0x38
-#define PRIV_STCRW                      0x39
-#define PRIV_STCPS                      0x3a
-#define PRIV_RCHP                       0x3b
-#define PRIV_SCHM                       0x3c
-#define PRIV_CHSC                       0x5f
-#define PRIV_SIGA                       0x74
-#define PRIV_XSCH                       0x76
-#define PRIV_SQBS                       0x8a
-#define PRIV_EQBS                       0x9c
+#define PRIV_B2_SCLP_CALL               0x20
+#define PRIV_B2_CSCH                    0x30
+#define PRIV_B2_HSCH                    0x31
+#define PRIV_B2_MSCH                    0x32
+#define PRIV_B2_SSCH                    0x33
+#define PRIV_B2_STSCH                   0x34
+#define PRIV_B2_TSCH                    0x35
+#define PRIV_B2_TPI                     0x36
+#define PRIV_B2_SAL                     0x37
+#define PRIV_B2_RSCH                    0x38
+#define PRIV_B2_STCRW                   0x39
+#define PRIV_B2_STCPS                   0x3a
+#define PRIV_B2_RCHP                    0x3b
+#define PRIV_B2_SCHM                    0x3c
+#define PRIV_B2_CHSC                    0x5f
+#define PRIV_B2_SIGA                    0x74
+#define PRIV_B2_XSCH                    0x76
+
+#define PRIV_EB_SQBS                    0x8a
+
+#define PRIV_B9_EQBS                    0x9c
+

 #define DIAG_IPL                        0x308
 #define DIAG_KVM_HYPERCALL              0x500
 #define DIAG_KVM_BREAKPOINT             0x501
 #define DIAG_IPL                        0x308
 #define DIAG_KVM_HYPERCALL              0x500
 #define DIAG_KVM_BREAKPOINT             0x501


@@ -82,22 +85,19 @@
 #define ICPT_CPU_STOP                   0x28
 #define ICPT_IO                         0x40
 
 #define ICPT_CPU_STOP                   0x28
 #define ICPT_IO                         0x40
 

-#define SIGP_RESTART                    0x06
-#define SIGP_INITIAL_CPU_RESET          0x0b
-#define SIGP_STORE_STATUS_ADDR          0x0e
-#define SIGP_SET_ARCH                   0x12
-

 const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
     KVM_CAP_LAST_INFO
 };
 
 static int cap_sync_regs;
 const KVMCapabilityInfo kvm_arch_required_capabilities[] = {
     KVM_CAP_LAST_INFO
 };
 
 static int cap_sync_regs;

+static int cap_async_pf;

 
 

-static void *legacy_s390_alloc(ram_addr_t size);
+static void *legacy_s390_alloc(size_t size);

 
 int kvm_arch_init(KVMState *s)
 {
     cap_sync_regs = kvm_check_extension(s, KVM_CAP_SYNC_REGS);
 
 int kvm_arch_init(KVMState *s)
 {
     cap_sync_regs = kvm_check_extension(s, KVM_CAP_SYNC_REGS);

+    cap_async_pf = kvm_check_extension(s, KVM_CAP_ASYNC_PF);

     if (!kvm_check_extension(s, KVM_CAP_S390_GMAP)
         || !kvm_check_extension(s, KVM_CAP_S390_COW)) {
         phys_mem_set_alloc(legacy_s390_alloc);
     if (!kvm_check_extension(s, KVM_CAP_S390_GMAP)
         || !kvm_check_extension(s, KVM_CAP_S390_COW)) {
         phys_mem_set_alloc(legacy_s390_alloc);


@@ -157,34 +157,54 @@ int kvm_arch_put_registers(CPUState *cs, int level)
         }
     }
 
         }
     }
 

-    if (env->runtime_reg_dirty_mask == KVM_S390_RUNTIME_DIRTY_FULL) {
-        reg.id = KVM_REG_S390_CPU_TIMER;
-        reg.addr = (__u64)&(env->cputm);
+    /* Do we need to save more than that? */
+    if (level == KVM_PUT_RUNTIME_STATE) {
+        return 0;
+    }
+
+    reg.id = KVM_REG_S390_CPU_TIMER;
+    reg.addr = (__u64)&(env->cputm);
+    ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
+    if (ret < 0) {
+        return ret;
+    }
+
+    reg.id = KVM_REG_S390_CLOCK_COMP;
+    reg.addr = (__u64)&(env->ckc);
+    ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
+    if (ret < 0) {
+        return ret;
+    }
+
+    reg.id = KVM_REG_S390_TODPR;
+    reg.addr = (__u64)&(env->todpr);
+    ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
+    if (ret < 0) {
+        return ret;
+    }
+
+    if (cap_async_pf) {
+        reg.id = KVM_REG_S390_PFTOKEN;
+        reg.addr = (__u64)&(env->pfault_token);

         ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
         if (ret < 0) {
             return ret;
         }
 
         ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
         if (ret < 0) {
             return ret;
         }
 

-        reg.id = KVM_REG_S390_CLOCK_COMP;
-        reg.addr = (__u64)&(env->ckc);
+        reg.id = KVM_REG_S390_PFCOMPARE;
+        reg.addr = (__u64)&(env->pfault_compare);

         ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
         if (ret < 0) {
             return ret;
         }
 
         ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
         if (ret < 0) {
             return ret;
         }
 

-        reg.id = KVM_REG_S390_TODPR;
-        reg.addr = (__u64)&(env->todpr);
+        reg.id = KVM_REG_S390_PFSELECT;
+        reg.addr = (__u64)&(env->pfault_select);

         ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
         if (ret < 0) {
             return ret;
         }
     }
         ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
         if (ret < 0) {
             return ret;
         }
     }

-    env->runtime_reg_dirty_mask = KVM_S390_RUNTIME_DIRTY_NONE;
-
-    /* Do we need to save more than that? */
-    if (level == KVM_PUT_RUNTIME_STATE) {
-        return 0;
-    }

 
     if (cap_sync_regs &&
         cs->kvm_run->kvm_valid_regs & KVM_SYNC_ACRS &&
 
     if (cap_sync_regs &&
         cs->kvm_run->kvm_valid_regs & KVM_SYNC_ACRS &&


@@ -221,50 +241,9 @@ int kvm_arch_get_registers(CPUState *cs)
     S390CPU *cpu = S390_CPU(cs);
     CPUS390XState *env = &cpu->env;
     struct kvm_one_reg reg;
     S390CPU *cpu = S390_CPU(cs);
     CPUS390XState *env = &cpu->env;
     struct kvm_one_reg reg;

-    int r;
-
-    r = kvm_s390_get_registers_partial(cs);
-    if (r < 0) {
-        return r;
-    }
-
-    reg.id = KVM_REG_S390_CPU_TIMER;
-    reg.addr = (__u64)&(env->cputm);
-    r = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
-    if (r < 0) {
-        return r;
-    }
-
-    reg.id = KVM_REG_S390_CLOCK_COMP;
-    reg.addr = (__u64)&(env->ckc);
-    r = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
-    if (r < 0) {
-        return r;
-    }
-
-    reg.id = KVM_REG_S390_TODPR;
-    reg.addr = (__u64)&(env->todpr);
-    r = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
-    if (r < 0) {
-        return r;
-    }
-
-    env->runtime_reg_dirty_mask = KVM_S390_RUNTIME_DIRTY_FULL;
-    return 0;
-}
-
-int kvm_s390_get_registers_partial(CPUState *cs)
-{
-    S390CPU *cpu = S390_CPU(cs);
-    CPUS390XState *env = &cpu->env;

     struct kvm_sregs sregs;
     struct kvm_regs regs;
     struct kvm_sregs sregs;
     struct kvm_regs regs;

-    int ret;
-    int i;
-
-    if (env->runtime_reg_dirty_mask) {
-        return 0;
-    }
+    int i, r;

 
     /* get the PSW */
     env->psw.addr = cs->kvm_run->psw_addr;
 
     /* get the PSW */
     env->psw.addr = cs->kvm_run->psw_addr;


@@ -276,9 +255,9 @@ int kvm_s390_get_registers_partial(CPUState *cs)
             env->regs[i] = cs->kvm_run->s.regs.gprs[i];
         }
     } else {
             env->regs[i] = cs->kvm_run->s.regs.gprs[i];
         }
     } else {

-        ret = kvm_vcpu_ioctl(cs, KVM_GET_REGS, &regs);
-        if (ret < 0) {
-            return ret;
+        r = kvm_vcpu_ioctl(cs, KVM_GET_REGS, &regs);
+        if (r < 0) {
+            return r;

         }
          for (i = 0; i < 16; i++) {
             env->regs[i] = regs.gprs[i];
         }
          for (i = 0; i < 16; i++) {
             env->regs[i] = regs.gprs[i];


@@ -294,9 +273,9 @@ int kvm_s390_get_registers_partial(CPUState *cs)
             env->cregs[i] = cs->kvm_run->s.regs.crs[i];
         }
     } else {
             env->cregs[i] = cs->kvm_run->s.regs.crs[i];
         }
     } else {

-        ret = kvm_vcpu_ioctl(cs, KVM_GET_SREGS, &sregs);
-        if (ret < 0) {
-            return ret;
+        r = kvm_vcpu_ioctl(cs, KVM_GET_SREGS, &sregs);
+        if (r < 0) {
+            return r;

         }
          for (i = 0; i < 16; i++) {
             env->aregs[i] = sregs.acrs[i];
         }
          for (i = 0; i < 16; i++) {
             env->aregs[i] = sregs.acrs[i];


@@ -304,14 +283,56 @@ int kvm_s390_get_registers_partial(CPUState *cs)
         }
     }
 
         }
     }
 

-    /* Finally the prefix */
+    /* The prefix */

     if (cap_sync_regs && cs->kvm_run->kvm_valid_regs & KVM_SYNC_PREFIX) {
         env->psa = cs->kvm_run->s.regs.prefix;
     if (cap_sync_regs && cs->kvm_run->kvm_valid_regs & KVM_SYNC_PREFIX) {
         env->psa = cs->kvm_run->s.regs.prefix;

-    } else {
-        /* no prefix without sync regs */

     }
 
     }
 

-    env->runtime_reg_dirty_mask = KVM_S390_RUNTIME_DIRTY_PARTIAL;
+    /* One Regs */
+    reg.id = KVM_REG_S390_CPU_TIMER;
+    reg.addr = (__u64)&(env->cputm);
+    r = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
+    if (r < 0) {
+        return r;
+    }
+
+    reg.id = KVM_REG_S390_CLOCK_COMP;
+    reg.addr = (__u64)&(env->ckc);
+    r = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
+    if (r < 0) {
+        return r;
+    }
+
+    reg.id = KVM_REG_S390_TODPR;
+    reg.addr = (__u64)&(env->todpr);
+    r = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
+    if (r < 0) {
+        return r;
+    }
+
+    if (cap_async_pf) {
+        reg.id = KVM_REG_S390_PFTOKEN;
+        reg.addr = (__u64)&(env->pfault_token);
+        r = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
+        if (r < 0) {
+            return r;
+        }
+
+        reg.id = KVM_REG_S390_PFCOMPARE;
+        reg.addr = (__u64)&(env->pfault_compare);
+        r = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
+        if (r < 0) {
+            return r;
+        }
+
+        reg.id = KVM_REG_S390_PFSELECT;
+        reg.addr = (__u64)&(env->pfault_select);
+        r = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
+        if (r < 0) {
+            return r;
+        }
+    }
+

     return 0;
 }
 
     return 0;
 }
 


@@ -325,7 +346,7 @@ int kvm_s390_get_registers_partial(CPUState *cs)
  * to grow. We also have to use MAP parameters that avoid
  * read-only mapping of guest pages.
  */
  * to grow. We also have to use MAP parameters that avoid
  * read-only mapping of guest pages.
  */

-static void *legacy_s390_alloc(ram_addr_t size)
+static void *legacy_s390_alloc(size_t size)

 {
     void *mem;
 
 {
     void *mem;
 


@@ -422,119 +443,128 @@ static int kvm_sclp_service_call(S390CPU *cpu, struct kvm_run *run,
                                  uint16_t ipbh0)
 {
     CPUS390XState *env = &cpu->env;
                                  uint16_t ipbh0)
 {
     CPUS390XState *env = &cpu->env;

-    uint32_t sccb;
-    uint64_t code;
+    uint64_t sccb;
+    uint32_t code;

     int r = 0;
 
     cpu_synchronize_state(CPU(cpu));
     int r = 0;
 
     cpu_synchronize_state(CPU(cpu));

-    if (env->psw.mask & PSW_MASK_PSTATE) {
-        enter_pgmcheck(cpu, PGM_PRIVILEGED);
-        return 0;
-    }

     sccb = env->regs[ipbh0 & 0xf];
     code = env->regs[(ipbh0 & 0xf0) >> 4];
 
     sccb = env->regs[ipbh0 & 0xf];
     code = env->regs[(ipbh0 & 0xf0) >> 4];
 

-    r = sclp_service_call(sccb, code);
+    r = sclp_service_call(env, sccb, code);

     if (r < 0) {
         enter_pgmcheck(cpu, -r);
     if (r < 0) {
         enter_pgmcheck(cpu, -r);

+    } else {
+        setcc(cpu, r);

     }
     }

-    setcc(cpu, r);

 
     return 0;
 }
 
 
     return 0;
 }
 

-static int kvm_handle_css_inst(S390CPU *cpu, struct kvm_run *run,
-                               uint8_t ipa0, uint8_t ipa1, uint8_t ipb)
+static int handle_b2(S390CPU *cpu, struct kvm_run *run, uint8_t ipa1)

 {
     CPUS390XState *env = &cpu->env;
 {
     CPUS390XState *env = &cpu->env;

-    CPUState *cs = CPU(cpu);
-
-    if (ipa0 != 0xb2) {
-        /* Not handled for now. */
-        return -1;
-    }
+    int rc = 0;
+    uint16_t ipbh0 = (run->s390_sieic.ipb & 0xffff0000) >> 16;

 
 

-    kvm_s390_get_registers_partial(cs);
-    cs->kvm_vcpu_dirty = true;
+    cpu_synchronize_state(CPU(cpu));

 
     switch (ipa1) {
 
     switch (ipa1) {

-    case PRIV_XSCH:
+    case PRIV_B2_XSCH:

         ioinst_handle_xsch(cpu, env->regs[1]);
         break;
         ioinst_handle_xsch(cpu, env->regs[1]);
         break;

-    case PRIV_CSCH:
+    case PRIV_B2_CSCH:

         ioinst_handle_csch(cpu, env->regs[1]);
         break;
         ioinst_handle_csch(cpu, env->regs[1]);
         break;

-    case PRIV_HSCH:
+    case PRIV_B2_HSCH:

         ioinst_handle_hsch(cpu, env->regs[1]);
         break;
         ioinst_handle_hsch(cpu, env->regs[1]);
         break;

-    case PRIV_MSCH:
+    case PRIV_B2_MSCH:

         ioinst_handle_msch(cpu, env->regs[1], run->s390_sieic.ipb);
         break;
         ioinst_handle_msch(cpu, env->regs[1], run->s390_sieic.ipb);
         break;

-    case PRIV_SSCH:
+    case PRIV_B2_SSCH:

         ioinst_handle_ssch(cpu, env->regs[1], run->s390_sieic.ipb);
         break;
         ioinst_handle_ssch(cpu, env->regs[1], run->s390_sieic.ipb);
         break;

-    case PRIV_STCRW:
+    case PRIV_B2_STCRW:

         ioinst_handle_stcrw(cpu, run->s390_sieic.ipb);
         break;
         ioinst_handle_stcrw(cpu, run->s390_sieic.ipb);
         break;

-    case PRIV_STSCH:
+    case PRIV_B2_STSCH:

         ioinst_handle_stsch(cpu, env->regs[1], run->s390_sieic.ipb);
         break;
         ioinst_handle_stsch(cpu, env->regs[1], run->s390_sieic.ipb);
         break;

-    case PRIV_TSCH:
+    case PRIV_B2_TSCH:

         /* We should only get tsch via KVM_EXIT_S390_TSCH. */
         fprintf(stderr, "Spurious tsch intercept\n");
         break;
         /* We should only get tsch via KVM_EXIT_S390_TSCH. */
         fprintf(stderr, "Spurious tsch intercept\n");
         break;

-    case PRIV_CHSC:
+    case PRIV_B2_CHSC:

         ioinst_handle_chsc(cpu, run->s390_sieic.ipb);
         break;
         ioinst_handle_chsc(cpu, run->s390_sieic.ipb);
         break;

-    case PRIV_TPI:
+    case PRIV_B2_TPI:

         /* This should have been handled by kvm already. */
         fprintf(stderr, "Spurious tpi intercept\n");
         break;
         /* This should have been handled by kvm already. */
         fprintf(stderr, "Spurious tpi intercept\n");
         break;

-    case PRIV_SCHM:
+    case PRIV_B2_SCHM:

         ioinst_handle_schm(cpu, env->regs[1], env->regs[2],
                            run->s390_sieic.ipb);
         break;
         ioinst_handle_schm(cpu, env->regs[1], env->regs[2],
                            run->s390_sieic.ipb);
         break;

-    case PRIV_RSCH:
+    case PRIV_B2_RSCH:

         ioinst_handle_rsch(cpu, env->regs[1]);
         break;
         ioinst_handle_rsch(cpu, env->regs[1]);
         break;

-    case PRIV_RCHP:
+    case PRIV_B2_RCHP:

         ioinst_handle_rchp(cpu, env->regs[1]);
         break;
         ioinst_handle_rchp(cpu, env->regs[1]);
         break;

-    case PRIV_STCPS:
+    case PRIV_B2_STCPS:

         /* We do not provide this instruction, it is suppressed. */
         break;
         /* We do not provide this instruction, it is suppressed. */
         break;

-    case PRIV_SAL:
+    case PRIV_B2_SAL:

         ioinst_handle_sal(cpu, env->regs[1]);
         break;
         ioinst_handle_sal(cpu, env->regs[1]);
         break;

-    case PRIV_SIGA:
+    case PRIV_B2_SIGA:

         /* Not provided, set CC = 3 for subchannel not operational */
         setcc(cpu, 3);
         break;
         /* Not provided, set CC = 3 for subchannel not operational */
         setcc(cpu, 3);
         break;

+    case PRIV_B2_SCLP_CALL:
+        rc = kvm_sclp_service_call(cpu, run, ipbh0);
+        break;

     default:
     default:

-        return -1;
+        rc = -1;
+        DPRINTF("KVM: unhandled PRIV: 0xb2%x\n", ipa1);
+        break;

     }
 
     }
 

-    return 0;
+    return rc;

 }
 
 }
 

-static int handle_priv(S390CPU *cpu, struct kvm_run *run,
-                       uint8_t ipa0, uint8_t ipa1)
+static int handle_b9(S390CPU *cpu, struct kvm_run *run, uint8_t ipa1)

 {
     int r = 0;
 {
     int r = 0;

-    uint16_t ipbh0 = (run->s390_sieic.ipb & 0xffff0000) >> 16;
-    uint8_t ipb = run->s390_sieic.ipb & 0xff;

 
 

-    DPRINTF("KVM: PRIV: %d\n", ipa1);

     switch (ipa1) {
     switch (ipa1) {

-        case PRIV_SCLP_CALL:
-            r = kvm_sclp_service_call(cpu, run, ipbh0);
-            break;
-        default:
-            r = kvm_handle_css_inst(cpu, run, ipa0, ipa1, ipb);
-            if (r == -1) {
-                DPRINTF("KVM: unhandled PRIV: 0x%x\n", ipa1);
-            }
-            break;
+    case PRIV_B9_EQBS:
+        /* just inject exception */
+        r = -1;
+        break;
+    default:
+        r = -1;
+        DPRINTF("KVM: unhandled PRIV: 0xb9%x\n", ipa1);
+        break;
+    }
+
+    return r;
+}
+
+static int handle_eb(S390CPU *cpu, struct kvm_run *run, uint8_t ipa1)
+{
+    int r = 0;
+
+    switch (ipa1) {
+    case PRIV_EB_SQBS:
+        /* just inject exception */
+        r = -1;
+        break;
+    default:
+        r = -1;
+        DPRINTF("KVM: unhandled PRIV: 0xeb%x\n", ipa1);
+        break;

     }
 
     return r;
     }
 
     return r;


@@ -542,14 +572,17 @@ static int handle_priv(S390CPU *cpu, struct kvm_run *run,
 
 static int handle_hypercall(S390CPU *cpu, struct kvm_run *run)
 {
 
 static int handle_hypercall(S390CPU *cpu, struct kvm_run *run)
 {

-    CPUState *cs = CPU(cpu);

     CPUS390XState *env = &cpu->env;
     CPUS390XState *env = &cpu->env;

+    int ret;

 
 

-    kvm_s390_get_registers_partial(cs);
-    cs->kvm_vcpu_dirty = true;
-    env->regs[2] = s390_virtio_hypercall(env);
+    cpu_synchronize_state(CPU(cpu));
+    ret = s390_virtio_hypercall(env);
+    if (ret == -EINVAL) {
+        enter_pgmcheck(cpu, PGM_SPECIFICATION);
+        return 0;
+    }

 
 

-    return 0;
+    return ret;

 }
 
 static void kvm_handle_diag_308(S390CPU *cpu, struct kvm_run *run)
 }
 
 static void kvm_handle_diag_308(S390CPU *cpu, struct kvm_run *run)


@@ -562,11 +595,19 @@ static void kvm_handle_diag_308(S390CPU *cpu, struct kvm_run *run)
     handle_diag_308(&cpu->env, r1, r3);
 }
 
     handle_diag_308(&cpu->env, r1, r3);
 }
 

-static int handle_diag(S390CPU *cpu, struct kvm_run *run, int ipb_code)
+#define DIAG_KVM_CODE_MASK 0x000000000000ffff
+
+static int handle_diag(S390CPU *cpu, struct kvm_run *run, uint32_t ipb)

 {
     int r = 0;
 {
     int r = 0;

-
-    switch (ipb_code) {
+    uint16_t func_code;
+
+    /*
+     * For any diagnose call we support, bits 48-63 of the resulting
+     * address specify the function code; the remainder is ignored.
+     */
+    func_code = decode_basedisp_rs(&cpu->env, ipb) & DIAG_KVM_CODE_MASK;
+    switch (func_code) {

     case DIAG_IPL:
         kvm_handle_diag_308(cpu, run);
         break;
     case DIAG_IPL:
         kvm_handle_diag_308(cpu, run);
         break;


@@ -577,7 +618,7 @@ static int handle_diag(S390CPU *cpu, struct kvm_run *run, int ipb_code)
         sleep(10);
         break;
     default:
         sleep(10);
         break;
     default:

-        DPRINTF("KVM: unknown DIAG: 0x%x\n", ipb_code);
+        DPRINTF("KVM: unknown DIAG: 0x%x\n", func_code);

         r = -1;
         break;
     }
         r = -1;
         break;
     }


@@ -585,6 +626,14 @@ static int handle_diag(S390CPU *cpu, struct kvm_run *run, int ipb_code)
     return r;
 }
 
     return r;
 }
 

+static int kvm_s390_cpu_start(S390CPU *cpu)
+{
+    s390_add_running_cpu(cpu);
+    qemu_cpu_kick(CPU(cpu));
+    DPRINTF("DONE: KVM cpu start: %p\n", &cpu->env);
+    return 0;
+}
+

 int kvm_s390_cpu_restart(S390CPU *cpu)
 {
     kvm_s390_interrupt(cpu, KVM_S390_RESTART, 0);
 int kvm_s390_cpu_restart(S390CPU *cpu)
 {
     kvm_s390_interrupt(cpu, KVM_S390_RESTART, 0);


@@ -594,89 +643,77 @@ int kvm_s390_cpu_restart(S390CPU *cpu)
     return 0;
 }
 
     return 0;
 }
 

-static int s390_store_status(CPUS390XState *env, uint32_t parameter)
+static void sigp_initial_cpu_reset(void *arg)

 {
 {

-    /* XXX */
-    fprintf(stderr, "XXX SIGP store status\n");
-    return -1;
+    CPUState *cpu = arg;
+    S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);
+
+    cpu_synchronize_state(cpu);
+    scc->initial_cpu_reset(cpu);

 }
 
 }
 

-static int s390_cpu_initial_reset(S390CPU *cpu)
+static void sigp_cpu_reset(void *arg)

 {
 {

-    CPUState *cs = CPU(cpu);
-    CPUS390XState *env = &cpu->env;
-    int i;
-
-    s390_del_running_cpu(cpu);
-    if (kvm_vcpu_ioctl(cs, KVM_S390_INITIAL_RESET, NULL) < 0) {
-        perror("cannot init reset vcpu");
-    }
+    CPUState *cpu = arg;
+    S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);

 
 

-    /* Manually zero out all registers */
-    cpu_synchronize_state(cs);
-    for (i = 0; i < 16; i++) {
-        env->regs[i] = 0;
-    }
-
-    DPRINTF("DONE: SIGP initial reset: %p\n", env);
-    return 0;
+    cpu_synchronize_state(cpu);
+    scc->cpu_reset(cpu);

 }
 
 }
 

+#define SIGP_ORDER_MASK 0x000000ff
+

 static int handle_sigp(S390CPU *cpu, struct kvm_run *run, uint8_t ipa1)
 {
     CPUS390XState *env = &cpu->env;
     uint8_t order_code;
 static int handle_sigp(S390CPU *cpu, struct kvm_run *run, uint8_t ipa1)
 {
     CPUS390XState *env = &cpu->env;
     uint8_t order_code;

-    uint32_t parameter;

     uint16_t cpu_addr;
     uint16_t cpu_addr;

-    uint8_t t;
-    int r = -1;

     S390CPU *target_cpu;
     S390CPU *target_cpu;

-    CPUS390XState *target_env;
+    uint64_t *statusreg = &env->regs[ipa1 >> 4];
+    int cc;

 
     cpu_synchronize_state(CPU(cpu));
 
     /* get order code */
 
     cpu_synchronize_state(CPU(cpu));
 
     /* get order code */

-    order_code = run->s390_sieic.ipb >> 28;
-    if (order_code > 0) {
-        order_code = env->regs[order_code];
-    }
-    order_code += (run->s390_sieic.ipb & 0x0fff0000) >> 16;
-
-    /* get parameters */
-    t = (ipa1 & 0xf0) >> 4;
-    if (!(t % 2)) {
-        t++;
-    }
+    order_code = decode_basedisp_rs(env, run->s390_sieic.ipb) & SIGP_ORDER_MASK;

 
 

-    parameter = env->regs[t] & 0x7ffffe00;

     cpu_addr = env->regs[ipa1 & 0x0f];
     cpu_addr = env->regs[ipa1 & 0x0f];

-

     target_cpu = s390_cpu_addr2state(cpu_addr);
     if (target_cpu == NULL) {
     target_cpu = s390_cpu_addr2state(cpu_addr);
     if (target_cpu == NULL) {

+        cc = 3;    /* not operational */

         goto out;
     }
         goto out;
     }

-    target_env = &target_cpu->env;

 
     switch (order_code) {
 
     switch (order_code) {

-        case SIGP_RESTART:
-            r = kvm_s390_cpu_restart(target_cpu);
-            break;
-        case SIGP_STORE_STATUS_ADDR:
-            r = s390_store_status(target_env, parameter);
-            break;
-        case SIGP_SET_ARCH:
-            /* make the caller panic */
-            return -1;
-        case SIGP_INITIAL_CPU_RESET:
-            r = s390_cpu_initial_reset(target_cpu);
-            break;
-        default:
-            fprintf(stderr, "KVM: unknown SIGP: 0x%x\n", order_code);
-            break;
+    case SIGP_START:
+        cc = kvm_s390_cpu_start(target_cpu);
+        break;
+    case SIGP_RESTART:
+        cc = kvm_s390_cpu_restart(target_cpu);
+        break;
+    case SIGP_SET_ARCH:
+        *statusreg &= 0xffffffff00000000UL;
+        *statusreg |= SIGP_STAT_INVALID_PARAMETER;
+        cc = 1;   /* status stored */
+        break;
+    case SIGP_INITIAL_CPU_RESET:
+        run_on_cpu(CPU(target_cpu), sigp_initial_cpu_reset, CPU(target_cpu));
+        cc = 0;
+        break;
+    case SIGP_CPU_RESET:
+        run_on_cpu(CPU(target_cpu), sigp_cpu_reset, CPU(target_cpu));
+        cc = 0;
+        break;
+    default:
+        DPRINTF("KVM: unknown SIGP: 0x%x\n", order_code);
+        *statusreg &= 0xffffffff00000000UL;
+        *statusreg |= SIGP_STAT_INVALID_ORDER;
+        cc = 1;   /* status stored */
+        break;

     }
 
 out:
     }
 
 out:

-    setcc(cpu, r ? 3 : 0);
+    setcc(cpu, cc);

     return 0;
 }
 
     return 0;
 }
 


@@ -684,19 +721,22 @@ static void handle_instruction(S390CPU *cpu, struct kvm_run *run)
 {
     unsigned int ipa0 = (run->s390_sieic.ipa & 0xff00);
     uint8_t ipa1 = run->s390_sieic.ipa & 0x00ff;
 {
     unsigned int ipa0 = (run->s390_sieic.ipa & 0xff00);
     uint8_t ipa1 = run->s390_sieic.ipa & 0x00ff;

-    int ipb_code = (run->s390_sieic.ipb & 0x0fff0000) >> 16;

     int r = -1;
 
     DPRINTF("handle_instruction 0x%x 0x%x\n",
             run->s390_sieic.ipa, run->s390_sieic.ipb);
     switch (ipa0) {
     case IPA0_B2:
     int r = -1;
 
     DPRINTF("handle_instruction 0x%x 0x%x\n",
             run->s390_sieic.ipa, run->s390_sieic.ipb);
     switch (ipa0) {
     case IPA0_B2:

+        r = handle_b2(cpu, run, ipa1);
+        break;

     case IPA0_B9:
     case IPA0_B9:

+        r = handle_b9(cpu, run, ipa1);
+        break;

     case IPA0_EB:
     case IPA0_EB:

-        r = handle_priv(cpu, run, ipa0 >> 8, ipa1);
+        r = handle_eb(cpu, run, ipa1);

         break;
     case IPA0_DIAG:
         break;
     case IPA0_DIAG:

-        r = handle_diag(cpu, run, ipb_code);
+        r = handle_diag(cpu, run, run->s390_sieic.ipb);

         break;
     case IPA0_SIGP:
         r = handle_sigp(cpu, run, ipa1);
         break;
     case IPA0_SIGP:
         r = handle_sigp(cpu, run, ipa1);


@@ -773,8 +813,7 @@ static int handle_tsch(S390CPU *cpu)
     struct kvm_run *run = cs->kvm_run;
     int ret;
 
     struct kvm_run *run = cs->kvm_run;
     int ret;
 

-    kvm_s390_get_registers_partial(cs);
-    cs->kvm_vcpu_dirty = true;
+    cpu_synchronize_state(cs);

 
     ret = ioinst_handle_tsch(env, env->regs[1], run->s390_tsch.ipb);
     if (ret >= 0) {
 
     ret = ioinst_handle_tsch(env, env->regs[1], run->s390_tsch.ipb);
     if (ret >= 0) {


@@ -852,8 +891,12 @@ void kvm_s390_io_interrupt(S390CPU *cpu, uint16_t subchannel_id,
 {
     uint32_t type;
 
 {
     uint32_t type;
 

-    type = ((subchannel_id & 0xff00) << 24) |
-        ((subchannel_id & 0x00060) << 22) | (subchannel_nr << 16);
+    if (io_int_word & IO_INT_WORD_AI) {
+        type = KVM_S390_INT_IO(1, 0, 0, 0);
+    } else {
+        type = ((subchannel_id & 0xff00) << 24) |
+            ((subchannel_id & 0x00060) << 22) | (subchannel_nr << 16);
+    }

     kvm_s390_interrupt_internal(cpu, type,
                                 ((uint32_t)subchannel_id << 16) | subchannel_nr,
                                 ((uint64_t)io_int_parm << 32) | io_int_word, 1);
     kvm_s390_interrupt_internal(cpu, type,
                                 ((uint32_t)subchannel_id << 16) | subchannel_nr,
                                 ((uint64_t)io_int_parm << 32) | io_int_word, 1);