Revision f9466733

b/hw/s390x/s390-virtio-bus.c
113 113

  
114 114
static void s390_virtio_irq(S390CPU *cpu, int config_change, uint64_t token)
115 115
{
116
    CPUS390XState *env = &cpu->env;
117

  
118 116
    if (kvm_enabled()) {
119 117
        kvm_s390_virtio_irq(cpu, config_change, token);
120 118
    } else {
121
        cpu_inject_ext(env, VIRTIO_EXT_CODE, config_change, token);
119
        cpu_inject_ext(cpu, VIRTIO_EXT_CODE, config_change, token);
122 120
    }
123 121
}
124 122

  
b/target-s390x/cpu.h
975 975
    return (ns << 9) / 125;
976 976
}
977 977

  
978
static inline void cpu_inject_ext(CPUS390XState *env, uint32_t code, uint32_t param,
978
static inline void cpu_inject_ext(S390CPU *cpu, uint32_t code, uint32_t param,
979 979
                                  uint64_t param64)
980 980
{
981
    CPUS390XState *env = &cpu->env;
982

  
981 983
    if (env->ext_index == MAX_EXT_QUEUE - 1) {
982 984
        /* ugh - can't queue anymore. Let's drop. */
983 985
        return;
......
994 996
    cpu_interrupt(env, CPU_INTERRUPT_HARD);
995 997
}
996 998

  
997
static inline void cpu_inject_io(CPUS390XState *env, uint16_t subchannel_id,
999
static inline void cpu_inject_io(S390CPU *cpu, uint16_t subchannel_id,
998 1000
                                 uint16_t subchannel_number,
999 1001
                                 uint32_t io_int_parm, uint32_t io_int_word)
1000 1002
{
1003
    CPUS390XState *env = &cpu->env;
1001 1004
    int isc = ffs(io_int_word << 2) - 1;
1002 1005

  
1003 1006
    if (env->io_index[isc] == MAX_IO_QUEUE - 1) {
......
1017 1020
    cpu_interrupt(env, CPU_INTERRUPT_HARD);
1018 1021
}
1019 1022

  
1020
static inline void cpu_inject_crw_mchk(CPUS390XState *env)
1023
static inline void cpu_inject_crw_mchk(S390CPU *cpu)
1021 1024
{
1025
    CPUS390XState *env = &cpu->env;
1026

  
1022 1027
    if (env->mchk_index == MAX_MCHK_QUEUE - 1) {
1023 1028
        /* ugh - can't queue anymore. Let's drop. */
1024 1029
        return;
......
1090 1095
        kvm_s390_io_interrupt(cpu, subchannel_id, subchannel_nr, io_int_parm,
1091 1096
                              io_int_word);
1092 1097
    } else {
1093
        cpu_inject_io(&cpu->env, subchannel_id, subchannel_nr, io_int_parm,
1098
        cpu_inject_io(cpu, subchannel_id, subchannel_nr, io_int_parm,
1094 1099
                      io_int_word);
1095 1100
    }
1096 1101
}
......
1100 1105
    if (kvm_enabled()) {
1101 1106
        kvm_s390_crw_mchk(cpu);
1102 1107
    } else {
1103
        cpu_inject_crw_mchk(&cpu->env);
1108
        cpu_inject_crw_mchk(cpu);
1104 1109
    }
1105 1110
}
1106 1111

  
b/target-s390x/helper.c
737 737

  
738 738
void do_interrupt(CPUS390XState *env)
739 739
{
740
    S390CPU *cpu = s390_env_get_cpu(env);
741

  
740 742
    qemu_log_mask(CPU_LOG_INT, "%s: %d at pc=%" PRIx64 "\n",
741 743
                  __func__, env->exception_index, env->psw.addr);
742 744

  
......
755 757
            /* code is already in env */
756 758
            env->exception_index = EXCP_EXT;
757 759
        } else if (env->pending_int & INTERRUPT_TOD) {
758
            cpu_inject_ext(env, 0x1004, 0, 0);
760
            cpu_inject_ext(cpu, 0x1004, 0, 0);
759 761
            env->exception_index = EXCP_EXT;
760 762
            env->pending_int &= ~INTERRUPT_EXT;
761 763
            env->pending_int &= ~INTERRUPT_TOD;
762 764
        } else if (env->pending_int & INTERRUPT_CPUTIMER) {
763
            cpu_inject_ext(env, 0x1005, 0, 0);
765
            cpu_inject_ext(cpu, 0x1005, 0, 0);
764 766
            env->exception_index = EXCP_EXT;
765 767
            env->pending_int &= ~INTERRUPT_EXT;
766 768
            env->pending_int &= ~INTERRUPT_TOD;
b/target-s390x/interrupt.c
24 24
#endif
25 25
    } else {
26 26
        env->psw.addr += 4;
27
        cpu_inject_ext(env, EXT_SERVICE, parm, 0);
27
        cpu_inject_ext(dummy_cpu, EXT_SERVICE, parm, 0);
28 28
    }
29 29
}
30 30
#endif

Also available in: Unified diff