← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to target-s390x/machine.c

  • Committer: Phil Dennis-Jordan
  • Author(s): Michael Tokarev
  • Date: 2017-05-23 06:58:03 UTC
  • Revision ID: phil@philjordan.eu-20170523065803-3subwvf3y8kzkjry
Tags: upstream-2.8+dfsg
Import upstream version 2.8+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-s390x/machine.c
 
1
/*
 
2
 * S390x machine definitions and functions
 
3
 *
 
4
 * Copyright IBM Corp. 2014
 
5
 *
 
6
 * Authors:
 
7
 *   Thomas Huth <thuth@linux.vnet.ibm.com>
 
8
 *   Christian Borntraeger <borntraeger@de.ibm.com>
 
9
 *   Jason J. Herne <jjherne@us.ibm.com>
 
10
 *
 
11
 * This work is free software; you can redistribute it and/or modify
 
12
 * it under the terms of the GNU General Public License as published
 
13
 * by the Free Software Foundation; either version 2 of the License,
 
14
 * or (at your option) any later version.
 
15
 */
 
16
 
 
17
#include "qemu/osdep.h"
 
18
#include "hw/hw.h"
 
19
#include "cpu.h"
 
20
#include "sysemu/kvm.h"
 
21
 
 
22
static int cpu_post_load(void *opaque, int version_id)
 
23
{
 
24
    S390CPU *cpu = opaque;
 
25
 
 
26
    /*
 
27
     * As the cpu state is pushed to kvm via kvm_set_mp_state rather
 
28
     * than via cpu_synchronize_state, we need update kvm here.
 
29
     */
 
30
    if (kvm_enabled()) {
 
31
        kvm_s390_set_cpu_state(cpu, cpu->env.cpu_state);
 
32
        return kvm_s390_vcpu_interrupt_post_load(cpu);
 
33
    }
 
34
 
 
35
    return 0;
 
36
}
 
37
static void cpu_pre_save(void *opaque)
 
38
{
 
39
    S390CPU *cpu = opaque;
 
40
 
 
41
    if (kvm_enabled()) {
 
42
        kvm_s390_vcpu_interrupt_pre_save(cpu);
 
43
    }
 
44
}
 
45
 
 
46
static inline bool fpu_needed(void *opaque)
 
47
{
 
48
    /* This looks odd, but we might want to NOT transfer fprs in the future */
 
49
    return true;
 
50
}
 
51
 
 
52
static const VMStateDescription vmstate_fpu = {
 
53
    .name = "cpu/fpu",
 
54
    .version_id = 1,
 
55
    .minimum_version_id = 1,
 
56
    .needed = fpu_needed,
 
57
    .fields = (VMStateField[]) {
 
58
        VMSTATE_UINT64(env.vregs[0][0].ll, S390CPU),
 
59
        VMSTATE_UINT64(env.vregs[1][0].ll, S390CPU),
 
60
        VMSTATE_UINT64(env.vregs[2][0].ll, S390CPU),
 
61
        VMSTATE_UINT64(env.vregs[3][0].ll, S390CPU),
 
62
        VMSTATE_UINT64(env.vregs[4][0].ll, S390CPU),
 
63
        VMSTATE_UINT64(env.vregs[5][0].ll, S390CPU),
 
64
        VMSTATE_UINT64(env.vregs[6][0].ll, S390CPU),
 
65
        VMSTATE_UINT64(env.vregs[7][0].ll, S390CPU),
 
66
        VMSTATE_UINT64(env.vregs[8][0].ll, S390CPU),
 
67
        VMSTATE_UINT64(env.vregs[9][0].ll, S390CPU),
 
68
        VMSTATE_UINT64(env.vregs[10][0].ll, S390CPU),
 
69
        VMSTATE_UINT64(env.vregs[11][0].ll, S390CPU),
 
70
        VMSTATE_UINT64(env.vregs[12][0].ll, S390CPU),
 
71
        VMSTATE_UINT64(env.vregs[13][0].ll, S390CPU),
 
72
        VMSTATE_UINT64(env.vregs[14][0].ll, S390CPU),
 
73
        VMSTATE_UINT64(env.vregs[15][0].ll, S390CPU),
 
74
        VMSTATE_UINT32(env.fpc, S390CPU),
 
75
        VMSTATE_END_OF_LIST()
 
76
    }
 
77
};
 
78
 
 
79
static bool vregs_needed(void *opaque)
 
80
{
 
81
    return s390_has_feat(S390_FEAT_VECTOR);
 
82
}
 
83
 
 
84
static const VMStateDescription vmstate_vregs = {
 
85
    .name = "cpu/vregs",
 
86
    .version_id = 1,
 
87
    .minimum_version_id = 1,
 
88
    .needed = vregs_needed,
 
89
    .fields = (VMStateField[]) {
 
90
        /* vregs[0][0] -> vregs[15][0] and fregs are overlays */
 
91
        VMSTATE_UINT64(env.vregs[16][0].ll, S390CPU),
 
92
        VMSTATE_UINT64(env.vregs[17][0].ll, S390CPU),
 
93
        VMSTATE_UINT64(env.vregs[18][0].ll, S390CPU),
 
94
        VMSTATE_UINT64(env.vregs[19][0].ll, S390CPU),
 
95
        VMSTATE_UINT64(env.vregs[20][0].ll, S390CPU),
 
96
        VMSTATE_UINT64(env.vregs[21][0].ll, S390CPU),
 
97
        VMSTATE_UINT64(env.vregs[22][0].ll, S390CPU),
 
98
        VMSTATE_UINT64(env.vregs[23][0].ll, S390CPU),
 
99
        VMSTATE_UINT64(env.vregs[24][0].ll, S390CPU),
 
100
        VMSTATE_UINT64(env.vregs[25][0].ll, S390CPU),
 
101
        VMSTATE_UINT64(env.vregs[26][0].ll, S390CPU),
 
102
        VMSTATE_UINT64(env.vregs[27][0].ll, S390CPU),
 
103
        VMSTATE_UINT64(env.vregs[28][0].ll, S390CPU),
 
104
        VMSTATE_UINT64(env.vregs[29][0].ll, S390CPU),
 
105
        VMSTATE_UINT64(env.vregs[30][0].ll, S390CPU),
 
106
        VMSTATE_UINT64(env.vregs[31][0].ll, S390CPU),
 
107
        VMSTATE_UINT64(env.vregs[0][1].ll, S390CPU),
 
108
        VMSTATE_UINT64(env.vregs[1][1].ll, S390CPU),
 
109
        VMSTATE_UINT64(env.vregs[2][1].ll, S390CPU),
 
110
        VMSTATE_UINT64(env.vregs[3][1].ll, S390CPU),
 
111
        VMSTATE_UINT64(env.vregs[4][1].ll, S390CPU),
 
112
        VMSTATE_UINT64(env.vregs[5][1].ll, S390CPU),
 
113
        VMSTATE_UINT64(env.vregs[6][1].ll, S390CPU),
 
114
        VMSTATE_UINT64(env.vregs[7][1].ll, S390CPU),
 
115
        VMSTATE_UINT64(env.vregs[8][1].ll, S390CPU),
 
116
        VMSTATE_UINT64(env.vregs[9][1].ll, S390CPU),
 
117
        VMSTATE_UINT64(env.vregs[10][1].ll, S390CPU),
 
118
        VMSTATE_UINT64(env.vregs[11][1].ll, S390CPU),
 
119
        VMSTATE_UINT64(env.vregs[12][1].ll, S390CPU),
 
120
        VMSTATE_UINT64(env.vregs[13][1].ll, S390CPU),
 
121
        VMSTATE_UINT64(env.vregs[14][1].ll, S390CPU),
 
122
        VMSTATE_UINT64(env.vregs[15][1].ll, S390CPU),
 
123
        VMSTATE_UINT64(env.vregs[16][1].ll, S390CPU),
 
124
        VMSTATE_UINT64(env.vregs[17][1].ll, S390CPU),
 
125
        VMSTATE_UINT64(env.vregs[18][1].ll, S390CPU),
 
126
        VMSTATE_UINT64(env.vregs[19][1].ll, S390CPU),
 
127
        VMSTATE_UINT64(env.vregs[20][1].ll, S390CPU),
 
128
        VMSTATE_UINT64(env.vregs[21][1].ll, S390CPU),
 
129
        VMSTATE_UINT64(env.vregs[22][1].ll, S390CPU),
 
130
        VMSTATE_UINT64(env.vregs[23][1].ll, S390CPU),
 
131
        VMSTATE_UINT64(env.vregs[24][1].ll, S390CPU),
 
132
        VMSTATE_UINT64(env.vregs[25][1].ll, S390CPU),
 
133
        VMSTATE_UINT64(env.vregs[26][1].ll, S390CPU),
 
134
        VMSTATE_UINT64(env.vregs[27][1].ll, S390CPU),
 
135
        VMSTATE_UINT64(env.vregs[28][1].ll, S390CPU),
 
136
        VMSTATE_UINT64(env.vregs[29][1].ll, S390CPU),
 
137
        VMSTATE_UINT64(env.vregs[30][1].ll, S390CPU),
 
138
        VMSTATE_UINT64(env.vregs[31][1].ll, S390CPU),
 
139
        VMSTATE_END_OF_LIST()
 
140
    }
 
141
};
 
142
 
 
143
static bool riccb_needed(void *opaque)
 
144
{
 
145
    return s390_has_feat(S390_FEAT_RUNTIME_INSTRUMENTATION);
 
146
}
 
147
 
 
148
const VMStateDescription vmstate_riccb = {
 
149
    .name = "cpu/riccb",
 
150
    .version_id = 1,
 
151
    .minimum_version_id = 1,
 
152
    .needed = riccb_needed,
 
153
    .fields = (VMStateField[]) {
 
154
        VMSTATE_UINT8_ARRAY(env.riccb, S390CPU, 64),
 
155
        VMSTATE_END_OF_LIST()
 
156
    }
 
157
};
 
158
 
 
159
const VMStateDescription vmstate_s390_cpu = {
 
160
    .name = "cpu",
 
161
    .post_load = cpu_post_load,
 
162
    .pre_save = cpu_pre_save,
 
163
    .version_id = 4,
 
164
    .minimum_version_id = 3,
 
165
    .fields      = (VMStateField[]) {
 
166
        VMSTATE_UINT64_ARRAY(env.regs, S390CPU, 16),
 
167
        VMSTATE_UINT64(env.psw.mask, S390CPU),
 
168
        VMSTATE_UINT64(env.psw.addr, S390CPU),
 
169
        VMSTATE_UINT64(env.psa, S390CPU),
 
170
        VMSTATE_UINT32(env.todpr, S390CPU),
 
171
        VMSTATE_UINT64(env.pfault_token, S390CPU),
 
172
        VMSTATE_UINT64(env.pfault_compare, S390CPU),
 
173
        VMSTATE_UINT64(env.pfault_select, S390CPU),
 
174
        VMSTATE_UINT64(env.cputm, S390CPU),
 
175
        VMSTATE_UINT64(env.ckc, S390CPU),
 
176
        VMSTATE_UINT64(env.gbea, S390CPU),
 
177
        VMSTATE_UINT64(env.pp, S390CPU),
 
178
        VMSTATE_UINT32_ARRAY(env.aregs, S390CPU, 16),
 
179
        VMSTATE_UINT64_ARRAY(env.cregs, S390CPU, 16),
 
180
        VMSTATE_UINT8(env.cpu_state, S390CPU),
 
181
        VMSTATE_UINT8(env.sigp_order, S390CPU),
 
182
        VMSTATE_UINT32_V(irqstate_saved_size, S390CPU, 4),
 
183
        VMSTATE_VBUFFER_UINT32(irqstate, S390CPU, 4, NULL, 0,
 
184
                               irqstate_saved_size),
 
185
        VMSTATE_END_OF_LIST()
 
186
    },
 
187
    .subsections = (const VMStateDescription*[]) {
 
188
        &vmstate_fpu,
 
189
        &vmstate_vregs,
 
190
        &vmstate_riccb,
 
191
        NULL
 
192
    },
 
193
};