← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to debian/patches/arm64/0017-target-arm-kvm-Split-32-bit-only-code-into-its-own-f.patch

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2014-02-04 12:13:08 UTC
  • mfrom: (10.1.45 sid)
  • Revision ID: package-import@ubuntu.com-20140204121308-1xq92lrfs75agw2g
Tags: 1.7.0+dfsg-3ubuntu1~ppa1
* Merge 1.7.0+dfsg-3 from debian.  Remaining changes:
  - debian/patches/ubuntu:
    * expose-vmx_qemu64cpu.patch
    * linaro (omap3) and arm64 patches
    * ubuntu/target-ppc-add-stubs-for-kvm-breakpoints: fix FTBFS
      on ppc
    * ubuntu/CVE-2013-4377.patch: fix denial of service via virtio
  - debian/qemu-system-x86.modprobe: set kvm_intel nested=1 options
  - debian/control:
    * add arm64 to Architectures
    * add qemu-common and qemu-system-aarch64 packages
  - debian/qemu-system-common.install: add debian/tmp/usr/lib
  - debian/qemu-system-common.preinst: add kvm group
  - debian/qemu-system-common.postinst: remove acl placed by udev,
    and add udevadm trigger.
  - qemu-system-x86.links: add eepro100.rom, remove pxe-virtio,
    pxe-e1000 and pxe-rtl8139.
  - add qemu-system-x86.qemu-kvm.upstart and .default
  - qemu-user-static.postinst-in: remove arm64 binfmt
  - debian/rules:
    * allow parallel build
    * add aarch64 to system_targets and sys_systems
    * add qemu-kvm-spice links
    * install qemu-system-x86.modprobe
  - add debian/qemu-system-common.links for OVMF.fd link
* Remove kvm-img, kvm-nbd, kvm-ifup and kvm-ifdown symlinks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/patches/arm64/0017-target-arm-kvm-Split-32-bit-only-code-into-its-own-f.patch
1
 
From fb7196f6cae01cfcd522bf98c9bbf25596dccb4a Mon Sep 17 00:00:00 2001
2
 
From: Peter Maydell <peter.maydell@linaro.org>
3
 
Date: Tue, 17 Dec 2013 19:42:29 +0000
4
 
Subject: [PATCH 17/49] target-arm/kvm: Split 32 bit only code into its own
5
 
 file
6
 
 
7
 
Split ARM KVM support code which is 32 bit specific out into its
8
 
own file, which we only compile on 32 bit hosts. This will give
9
 
us a place to add the 64 bit support code without adding lots of
10
 
ifdefs to kvm.c.
11
 
 
12
 
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
13
 
Message-id: 1385645602-18662-2-git-send-email-peter.maydell@linaro.org
14
 
Reviewed-by: Christoffer Dall <christoffer.dall@linaro.org>
15
 
---
16
 
 target-arm/Makefile.objs |   1 +
17
 
 target-arm/kvm.c         | 491 --------------------------------------------
18
 
 target-arm/kvm32.c       | 515 +++++++++++++++++++++++++++++++++++++++++++++++
19
 
 3 files changed, 516 insertions(+), 491 deletions(-)
20
 
 create mode 100644 target-arm/kvm32.c
21
 
 
22
 
diff --git a/target-arm/Makefile.objs b/target-arm/Makefile.objs
23
 
index 356fbfc..c9f7944 100644
24
 
--- a/target-arm/Makefile.objs
25
 
+++ b/target-arm/Makefile.objs
26
 
@@ -1,6 +1,7 @@
27
 
 obj-y += arm-semi.o
28
 
 obj-$(CONFIG_SOFTMMU) += machine.o
29
 
 obj-$(CONFIG_KVM) += kvm.o
30
 
+obj-$(call land,$(CONFIG_KVM),$(call lnot,$(TARGET_AARCH64))) += kvm32.o
31
 
 obj-$(call lnot,$(CONFIG_KVM)) += kvm-stub.o
32
 
 obj-y += translate.o op_helper.o helper.o cpu.o
33
 
 obj-y += neon_helper.o iwmmxt_helper.o
34
 
diff --git a/target-arm/kvm.c b/target-arm/kvm.c
35
 
index f865dac..5cdb3b9 100644
36
 
--- a/target-arm/kvm.c
37
 
+++ b/target-arm/kvm.c
38
 
@@ -100,120 +100,6 @@ void kvm_arm_destroy_scratch_host_vcpu(int *fdarray)
39
 
     }
40
 
 }
41
 
 
42
 
-static inline void set_feature(uint64_t *features, int feature)
43
 
-{
44
 
-    *features |= 1ULL << feature;
45
 
-}
46
 
-
47
 
-bool kvm_arm_get_host_cpu_features(ARMHostCPUClass *ahcc)
48
 
-{
49
 
-    /* Identify the feature bits corresponding to the host CPU, and
50
 
-     * fill out the ARMHostCPUClass fields accordingly. To do this
51
 
-     * we have to create a scratch VM, create a single CPU inside it,
52
 
-     * and then query that CPU for the relevant ID registers.
53
 
-     */
54
 
-    int i, ret, fdarray[3];
55
 
-    uint32_t midr, id_pfr0, id_isar0, mvfr1;
56
 
-    uint64_t features = 0;
57
 
-    /* Old kernels may not know about the PREFERRED_TARGET ioctl: however
58
 
-     * we know these will only support creating one kind of guest CPU,
59
 
-     * which is its preferred CPU type.
60
 
-     */
61
 
-    static const uint32_t cpus_to_try[] = {
62
 
-        QEMU_KVM_ARM_TARGET_CORTEX_A15,
63
 
-        QEMU_KVM_ARM_TARGET_NONE
64
 
-    };
65
 
-    struct kvm_vcpu_init init;
66
 
-    struct kvm_one_reg idregs[] = {
67
 
-        {
68
 
-            .id = KVM_REG_ARM | KVM_REG_SIZE_U32
69
 
-            | ENCODE_CP_REG(15, 0, 0, 0, 0, 0),
70
 
-            .addr = (uintptr_t)&midr,
71
 
-        },
72
 
-        {
73
 
-            .id = KVM_REG_ARM | KVM_REG_SIZE_U32
74
 
-            | ENCODE_CP_REG(15, 0, 0, 1, 0, 0),
75
 
-            .addr = (uintptr_t)&id_pfr0,
76
 
-        },
77
 
-        {
78
 
-            .id = KVM_REG_ARM | KVM_REG_SIZE_U32
79
 
-            | ENCODE_CP_REG(15, 0, 0, 2, 0, 0),
80
 
-            .addr = (uintptr_t)&id_isar0,
81
 
-        },
82
 
-        {
83
 
-            .id = KVM_REG_ARM | KVM_REG_SIZE_U32
84
 
-            | KVM_REG_ARM_VFP | KVM_REG_ARM_VFP_MVFR1,
85
 
-            .addr = (uintptr_t)&mvfr1,
86
 
-        },
87
 
-    };
88
 
-
89
 
-    if (!kvm_arm_create_scratch_host_vcpu(cpus_to_try, fdarray, &init)) {
90
 
-        return false;
91
 
-    }
92
 
-
93
 
-    ahcc->target = init.target;
94
 
-
95
 
-    /* This is not strictly blessed by the device tree binding docs yet,
96
 
-     * but in practice the kernel does not care about this string so
97
 
-     * there is no point maintaining an KVM_ARM_TARGET_* -> string table.
98
 
-     */
99
 
-    ahcc->dtb_compatible = "arm,arm-v7";
100
 
-
101
 
-    for (i = 0; i < ARRAY_SIZE(idregs); i++) {
102
 
-        ret = ioctl(fdarray[2], KVM_GET_ONE_REG, &idregs[i]);
103
 
-        if (ret) {
104
 
-            break;
105
 
-        }
106
 
-    }
107
 
-
108
 
-    kvm_arm_destroy_scratch_host_vcpu(fdarray);
109
 
-
110
 
-    if (ret) {
111
 
-        return false;
112
 
-    }
113
 
-
114
 
-    /* Now we've retrieved all the register information we can
115
 
-     * set the feature bits based on the ID register fields.
116
 
-     * We can assume any KVM supporting CPU is at least a v7
117
 
-     * with VFPv3, LPAE and the generic timers; this in turn implies
118
 
-     * most of the other feature bits, but a few must be tested.
119
 
-     */
120
 
-    set_feature(&features, ARM_FEATURE_V7);
121
 
-    set_feature(&features, ARM_FEATURE_VFP3);
122
 
-    set_feature(&features, ARM_FEATURE_LPAE);
123
 
-    set_feature(&features, ARM_FEATURE_GENERIC_TIMER);
124
 
-
125
 
-    switch (extract32(id_isar0, 24, 4)) {
126
 
-    case 1:
127
 
-        set_feature(&features, ARM_FEATURE_THUMB_DIV);
128
 
-        break;
129
 
-    case 2:
130
 
-        set_feature(&features, ARM_FEATURE_ARM_DIV);
131
 
-        set_feature(&features, ARM_FEATURE_THUMB_DIV);
132
 
-        break;
133
 
-    default:
134
 
-        break;
135
 
-    }
136
 
-
137
 
-    if (extract32(id_pfr0, 12, 4) == 1) {
138
 
-        set_feature(&features, ARM_FEATURE_THUMB2EE);
139
 
-    }
140
 
-    if (extract32(mvfr1, 20, 4) == 1) {
141
 
-        set_feature(&features, ARM_FEATURE_VFP_FP16);
142
 
-    }
143
 
-    if (extract32(mvfr1, 12, 4) == 1) {
144
 
-        set_feature(&features, ARM_FEATURE_NEON);
145
 
-    }
146
 
-    if (extract32(mvfr1, 28, 4) == 1) {
147
 
-        /* FMAC support implies VFPv4 */
148
 
-        set_feature(&features, ARM_FEATURE_VFP4);
149
 
-    }
150
 
-
151
 
-    ahcc->features = features;
152
 
-
153
 
-    return true;
154
 
-}
155
 
-
156
 
 static void kvm_arm_host_cpu_class_init(ObjectClass *oc, void *data)
157
 
 {
158
 
     ARMHostCPUClass *ahcc = ARM_HOST_CPU_CLASS(oc);
159
 
@@ -265,144 +151,6 @@ unsigned long kvm_arch_vcpu_id(CPUState *cpu)
160
 
     return cpu->cpu_index;
161
 
 }
162
 
 
163
 
-static bool reg_syncs_via_tuple_list(uint64_t regidx)
164
 
-{
165
 
-    /* Return true if the regidx is a register we should synchronize
166
 
-     * via the cpreg_tuples array (ie is not a core reg we sync by
167
 
-     * hand in kvm_arch_get/put_registers())
168
 
-     */
169
 
-    switch (regidx & KVM_REG_ARM_COPROC_MASK) {
170
 
-    case KVM_REG_ARM_CORE:
171
 
-    case KVM_REG_ARM_VFP:
172
 
-        return false;
173
 
-    default:
174
 
-        return true;
175
 
-    }
176
 
-}
177
 
-
178
 
-static int compare_u64(const void *a, const void *b)
179
 
-{
180
 
-    if (*(uint64_t *)a > *(uint64_t *)b) {
181
 
-        return 1;
182
 
-    }
183
 
-    if (*(uint64_t *)a < *(uint64_t *)b) {
184
 
-        return -1;
185
 
-    }
186
 
-    return 0;
187
 
-}
188
 
-
189
 
-int kvm_arch_init_vcpu(CPUState *cs)
190
 
-{
191
 
-    struct kvm_vcpu_init init;
192
 
-    int i, ret, arraylen;
193
 
-    uint64_t v;
194
 
-    struct kvm_one_reg r;
195
 
-    struct kvm_reg_list rl;
196
 
-    struct kvm_reg_list *rlp;
197
 
-    ARMCPU *cpu = ARM_CPU(cs);
198
 
-
199
 
-    if (cpu->kvm_target == QEMU_KVM_ARM_TARGET_NONE) {
200
 
-        fprintf(stderr, "KVM is not supported for this guest CPU type\n");
201
 
-        return -EINVAL;
202
 
-    }
203
 
-
204
 
-    init.target = cpu->kvm_target;
205
 
-    memset(init.features, 0, sizeof(init.features));
206
 
-    if (cpu->start_powered_off) {
207
 
-        init.features[0] = 1 << KVM_ARM_VCPU_POWER_OFF;
208
 
-    }
209
 
-    ret = kvm_vcpu_ioctl(cs, KVM_ARM_VCPU_INIT, &init);
210
 
-    if (ret) {
211
 
-        return ret;
212
 
-    }
213
 
-    /* Query the kernel to make sure it supports 32 VFP
214
 
-     * registers: QEMU's "cortex-a15" CPU is always a
215
 
-     * VFP-D32 core. The simplest way to do this is just
216
 
-     * to attempt to read register d31.
217
 
-     */
218
 
-    r.id = KVM_REG_ARM | KVM_REG_SIZE_U64 | KVM_REG_ARM_VFP | 31;
219
 
-    r.addr = (uintptr_t)(&v);
220
 
-    ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &r);
221
 
-    if (ret == -ENOENT) {
222
 
-        return -EINVAL;
223
 
-    }
224
 
-
225
 
-    /* Populate the cpreg list based on the kernel's idea
226
 
-     * of what registers exist (and throw away the TCG-created list).
227
 
-     */
228
 
-    rl.n = 0;
229
 
-    ret = kvm_vcpu_ioctl(cs, KVM_GET_REG_LIST, &rl);
230
 
-    if (ret != -E2BIG) {
231
 
-        return ret;
232
 
-    }
233
 
-    rlp = g_malloc(sizeof(struct kvm_reg_list) + rl.n * sizeof(uint64_t));
234
 
-    rlp->n = rl.n;
235
 
-    ret = kvm_vcpu_ioctl(cs, KVM_GET_REG_LIST, rlp);
236
 
-    if (ret) {
237
 
-        goto out;
238
 
-    }
239
 
-    /* Sort the list we get back from the kernel, since cpreg_tuples
240
 
-     * must be in strictly ascending order.
241
 
-     */
242
 
-    qsort(&rlp->reg, rlp->n, sizeof(rlp->reg[0]), compare_u64);
243
 
-
244
 
-    for (i = 0, arraylen = 0; i < rlp->n; i++) {
245
 
-        if (!reg_syncs_via_tuple_list(rlp->reg[i])) {
246
 
-            continue;
247
 
-        }
248
 
-        switch (rlp->reg[i] & KVM_REG_SIZE_MASK) {
249
 
-        case KVM_REG_SIZE_U32:
250
 
-        case KVM_REG_SIZE_U64:
251
 
-            break;
252
 
-        default:
253
 
-            fprintf(stderr, "Can't handle size of register in kernel list\n");
254
 
-            ret = -EINVAL;
255
 
-            goto out;
256
 
-        }
257
 
-
258
 
-        arraylen++;
259
 
-    }
260
 
-
261
 
-    cpu->cpreg_indexes = g_renew(uint64_t, cpu->cpreg_indexes, arraylen);
262
 
-    cpu->cpreg_values = g_renew(uint64_t, cpu->cpreg_values, arraylen);
263
 
-    cpu->cpreg_vmstate_indexes = g_renew(uint64_t, cpu->cpreg_vmstate_indexes,
264
 
-                                         arraylen);
265
 
-    cpu->cpreg_vmstate_values = g_renew(uint64_t, cpu->cpreg_vmstate_values,
266
 
-                                        arraylen);
267
 
-    cpu->cpreg_array_len = arraylen;
268
 
-    cpu->cpreg_vmstate_array_len = arraylen;
269
 
-
270
 
-    for (i = 0, arraylen = 0; i < rlp->n; i++) {
271
 
-        uint64_t regidx = rlp->reg[i];
272
 
-        if (!reg_syncs_via_tuple_list(regidx)) {
273
 
-            continue;
274
 
-        }
275
 
-        cpu->cpreg_indexes[arraylen] = regidx;
276
 
-        arraylen++;
277
 
-    }
278
 
-    assert(cpu->cpreg_array_len == arraylen);
279
 
-
280
 
-    if (!write_kvmstate_to_list(cpu)) {
281
 
-        /* Shouldn't happen unless kernel is inconsistent about
282
 
-         * what registers exist.
283
 
-         */
284
 
-        fprintf(stderr, "Initial read of kernel register state failed\n");
285
 
-        ret = -EINVAL;
286
 
-        goto out;
287
 
-    }
288
 
-
289
 
-    /* Save a copy of the initial register values so that we can
290
 
-     * feed it back to the kernel on VCPU reset.
291
 
-     */
292
 
-    cpu->cpreg_reset_values = g_memdup(cpu->cpreg_values,
293
 
-                                       cpu->cpreg_array_len *
294
 
-                                       sizeof(cpu->cpreg_values[0]));
295
 
-
296
 
-out:
297
 
-    g_free(rlp);
298
 
-    return ret;
299
 
-}
300
 
-
301
 
 /* We track all the KVM devices which need their memory addresses
302
 
  * passing to the kernel in a list of these structures.
303
 
  * When board init is complete we run through the list and
304
 
@@ -563,232 +311,6 @@ bool write_list_to_kvmstate(ARMCPU *cpu)
305
 
     return ok;
306
 
 }
307
 
 
308
 
-typedef struct Reg {
309
 
-    uint64_t id;
310
 
-    int offset;
311
 
-} Reg;
312
 
-
313
 
-#define COREREG(KERNELNAME, QEMUFIELD)                       \
314
 
-    {                                                        \
315
 
-        KVM_REG_ARM | KVM_REG_SIZE_U32 |                     \
316
 
-        KVM_REG_ARM_CORE | KVM_REG_ARM_CORE_REG(KERNELNAME), \
317
 
-        offsetof(CPUARMState, QEMUFIELD)                     \
318
 
-    }
319
 
-
320
 
-#define VFPSYSREG(R)                                       \
321
 
-    {                                                      \
322
 
-        KVM_REG_ARM | KVM_REG_SIZE_U32 | KVM_REG_ARM_VFP | \
323
 
-        KVM_REG_ARM_VFP_##R,                               \
324
 
-        offsetof(CPUARMState, vfp.xregs[ARM_VFP_##R])      \
325
 
-    }
326
 
-
327
 
-static const Reg regs[] = {
328
 
-    /* R0_usr .. R14_usr */
329
 
-    COREREG(usr_regs.uregs[0], regs[0]),
330
 
-    COREREG(usr_regs.uregs[1], regs[1]),
331
 
-    COREREG(usr_regs.uregs[2], regs[2]),
332
 
-    COREREG(usr_regs.uregs[3], regs[3]),
333
 
-    COREREG(usr_regs.uregs[4], regs[4]),
334
 
-    COREREG(usr_regs.uregs[5], regs[5]),
335
 
-    COREREG(usr_regs.uregs[6], regs[6]),
336
 
-    COREREG(usr_regs.uregs[7], regs[7]),
337
 
-    COREREG(usr_regs.uregs[8], usr_regs[0]),
338
 
-    COREREG(usr_regs.uregs[9], usr_regs[1]),
339
 
-    COREREG(usr_regs.uregs[10], usr_regs[2]),
340
 
-    COREREG(usr_regs.uregs[11], usr_regs[3]),
341
 
-    COREREG(usr_regs.uregs[12], usr_regs[4]),
342
 
-    COREREG(usr_regs.uregs[13], banked_r13[0]),
343
 
-    COREREG(usr_regs.uregs[14], banked_r14[0]),
344
 
-    /* R13, R14, SPSR for SVC, ABT, UND, IRQ banks */
345
 
-    COREREG(svc_regs[0], banked_r13[1]),
346
 
-    COREREG(svc_regs[1], banked_r14[1]),
347
 
-    COREREG(svc_regs[2], banked_spsr[1]),
348
 
-    COREREG(abt_regs[0], banked_r13[2]),
349
 
-    COREREG(abt_regs[1], banked_r14[2]),
350
 
-    COREREG(abt_regs[2], banked_spsr[2]),
351
 
-    COREREG(und_regs[0], banked_r13[3]),
352
 
-    COREREG(und_regs[1], banked_r14[3]),
353
 
-    COREREG(und_regs[2], banked_spsr[3]),
354
 
-    COREREG(irq_regs[0], banked_r13[4]),
355
 
-    COREREG(irq_regs[1], banked_r14[4]),
356
 
-    COREREG(irq_regs[2], banked_spsr[4]),
357
 
-    /* R8_fiq .. R14_fiq and SPSR_fiq */
358
 
-    COREREG(fiq_regs[0], fiq_regs[0]),
359
 
-    COREREG(fiq_regs[1], fiq_regs[1]),
360
 
-    COREREG(fiq_regs[2], fiq_regs[2]),
361
 
-    COREREG(fiq_regs[3], fiq_regs[3]),
362
 
-    COREREG(fiq_regs[4], fiq_regs[4]),
363
 
-    COREREG(fiq_regs[5], banked_r13[5]),
364
 
-    COREREG(fiq_regs[6], banked_r14[5]),
365
 
-    COREREG(fiq_regs[7], banked_spsr[5]),
366
 
-    /* R15 */
367
 
-    COREREG(usr_regs.uregs[15], regs[15]),
368
 
-    /* VFP system registers */
369
 
-    VFPSYSREG(FPSID),
370
 
-    VFPSYSREG(MVFR1),
371
 
-    VFPSYSREG(MVFR0),
372
 
-    VFPSYSREG(FPEXC),
373
 
-    VFPSYSREG(FPINST),
374
 
-    VFPSYSREG(FPINST2),
375
 
-};
376
 
-
377
 
-int kvm_arch_put_registers(CPUState *cs, int level)
378
 
-{
379
 
-    ARMCPU *cpu = ARM_CPU(cs);
380
 
-    CPUARMState *env = &cpu->env;
381
 
-    struct kvm_one_reg r;
382
 
-    int mode, bn;
383
 
-    int ret, i;
384
 
-    uint32_t cpsr, fpscr;
385
 
-
386
 
-    /* Make sure the banked regs are properly set */
387
 
-    mode = env->uncached_cpsr & CPSR_M;
388
 
-    bn = bank_number(mode);
389
 
-    if (mode == ARM_CPU_MODE_FIQ) {
390
 
-        memcpy(env->fiq_regs, env->regs + 8, 5 * sizeof(uint32_t));
391
 
-    } else {
392
 
-        memcpy(env->usr_regs, env->regs + 8, 5 * sizeof(uint32_t));
393
 
-    }
394
 
-    env->banked_r13[bn] = env->regs[13];
395
 
-    env->banked_r14[bn] = env->regs[14];
396
 
-    env->banked_spsr[bn] = env->spsr;
397
 
-
398
 
-    /* Now we can safely copy stuff down to the kernel */
399
 
-    for (i = 0; i < ARRAY_SIZE(regs); i++) {
400
 
-        r.id = regs[i].id;
401
 
-        r.addr = (uintptr_t)(env) + regs[i].offset;
402
 
-        ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &r);
403
 
-        if (ret) {
404
 
-            return ret;
405
 
-        }
406
 
-    }
407
 
-
408
 
-    /* Special cases which aren't a single CPUARMState field */
409
 
-    cpsr = cpsr_read(env);
410
 
-    r.id = KVM_REG_ARM | KVM_REG_SIZE_U32 |
411
 
-        KVM_REG_ARM_CORE | KVM_REG_ARM_CORE_REG(usr_regs.ARM_cpsr);
412
 
-    r.addr = (uintptr_t)(&cpsr);
413
 
-    ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &r);
414
 
-    if (ret) {
415
 
-        return ret;
416
 
-    }
417
 
-
418
 
-    /* VFP registers */
419
 
-    r.id = KVM_REG_ARM | KVM_REG_SIZE_U64 | KVM_REG_ARM_VFP;
420
 
-    for (i = 0; i < 32; i++) {
421
 
-        r.addr = (uintptr_t)(&env->vfp.regs[i]);
422
 
-        ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &r);
423
 
-        if (ret) {
424
 
-            return ret;
425
 
-        }
426
 
-        r.id++;
427
 
-    }
428
 
-
429
 
-    r.id = KVM_REG_ARM | KVM_REG_SIZE_U32 | KVM_REG_ARM_VFP |
430
 
-        KVM_REG_ARM_VFP_FPSCR;
431
 
-    fpscr = vfp_get_fpscr(env);
432
 
-    r.addr = (uintptr_t)&fpscr;
433
 
-    ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &r);
434
 
-    if (ret) {
435
 
-        return ret;
436
 
-    }
437
 
-
438
 
-    /* Note that we do not call write_cpustate_to_list()
439
 
-     * here, so we are only writing the tuple list back to
440
 
-     * KVM. This is safe because nothing can change the
441
 
-     * CPUARMState cp15 fields (in particular gdb accesses cannot)
442
 
-     * and so there are no changes to sync. In fact syncing would
443
 
-     * be wrong at this point: for a constant register where TCG and
444
 
-     * KVM disagree about its value, the preceding write_list_to_cpustate()
445
 
-     * would not have had any effect on the CPUARMState value (since the
446
 
-     * register is read-only), and a write_cpustate_to_list() here would
447
 
-     * then try to write the TCG value back into KVM -- this would either
448
 
-     * fail or incorrectly change the value the guest sees.
449
 
-     *
450
 
-     * If we ever want to allow the user to modify cp15 registers via
451
 
-     * the gdb stub, we would need to be more clever here (for instance
452
 
-     * tracking the set of registers kvm_arch_get_registers() successfully
453
 
-     * managed to update the CPUARMState with, and only allowing those
454
 
-     * to be written back up into the kernel).
455
 
-     */
456
 
-    if (!write_list_to_kvmstate(cpu)) {
457
 
-        return EINVAL;
458
 
-    }
459
 
-
460
 
-    return ret;
461
 
-}
462
 
-
463
 
-int kvm_arch_get_registers(CPUState *cs)
464
 
-{
465
 
-    ARMCPU *cpu = ARM_CPU(cs);
466
 
-    CPUARMState *env = &cpu->env;
467
 
-    struct kvm_one_reg r;
468
 
-    int mode, bn;
469
 
-    int ret, i;
470
 
-    uint32_t cpsr, fpscr;
471
 
-
472
 
-    for (i = 0; i < ARRAY_SIZE(regs); i++) {
473
 
-        r.id = regs[i].id;
474
 
-        r.addr = (uintptr_t)(env) + regs[i].offset;
475
 
-        ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &r);
476
 
-        if (ret) {
477
 
-            return ret;
478
 
-        }
479
 
-    }
480
 
-
481
 
-    /* Special cases which aren't a single CPUARMState field */
482
 
-    r.id = KVM_REG_ARM | KVM_REG_SIZE_U32 |
483
 
-        KVM_REG_ARM_CORE | KVM_REG_ARM_CORE_REG(usr_regs.ARM_cpsr);
484
 
-    r.addr = (uintptr_t)(&cpsr);
485
 
-    ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &r);
486
 
-    if (ret) {
487
 
-        return ret;
488
 
-    }
489
 
-    cpsr_write(env, cpsr, 0xffffffff);
490
 
-
491
 
-    /* Make sure the current mode regs are properly set */
492
 
-    mode = env->uncached_cpsr & CPSR_M;
493
 
-    bn = bank_number(mode);
494
 
-    if (mode == ARM_CPU_MODE_FIQ) {
495
 
-        memcpy(env->regs + 8, env->fiq_regs, 5 * sizeof(uint32_t));
496
 
-    } else {
497
 
-        memcpy(env->regs + 8, env->usr_regs, 5 * sizeof(uint32_t));
498
 
-    }
499
 
-    env->regs[13] = env->banked_r13[bn];
500
 
-    env->regs[14] = env->banked_r14[bn];
501
 
-    env->spsr = env->banked_spsr[bn];
502
 
-
503
 
-    /* VFP registers */
504
 
-    r.id = KVM_REG_ARM | KVM_REG_SIZE_U64 | KVM_REG_ARM_VFP;
505
 
-    for (i = 0; i < 32; i++) {
506
 
-        r.addr = (uintptr_t)(&env->vfp.regs[i]);
507
 
-        ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &r);
508
 
-        if (ret) {
509
 
-            return ret;
510
 
-        }
511
 
-        r.id++;
512
 
-    }
513
 
-
514
 
-    r.id = KVM_REG_ARM | KVM_REG_SIZE_U32 | KVM_REG_ARM_VFP |
515
 
-        KVM_REG_ARM_VFP_FPSCR;
516
 
-    r.addr = (uintptr_t)&fpscr;
517
 
-    ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &r);
518
 
-    if (ret) {
519
 
-        return ret;
520
 
-    }
521
 
-    vfp_set_fpscr(env, fpscr);
522
 
-
523
 
-    if (!write_kvmstate_to_list(cpu)) {
524
 
-        return EINVAL;
525
 
-    }
526
 
-    /* Note that it's OK to have registers which aren't in CPUState,
527
 
-     * so we can ignore a failure return here.
528
 
-     */
529
 
-    write_list_to_cpustate(cpu);
530
 
-
531
 
-    return 0;
532
 
-}
533
 
-
534
 
 void kvm_arch_pre_run(CPUState *cs, struct kvm_run *run)
535
 
 {
536
 
 }
537
 
@@ -802,19 +324,6 @@ int kvm_arch_handle_exit(CPUState *cs, struct kvm_run *run)
538
 
     return 0;
539
 
 }
540
 
 
541
 
-void kvm_arch_reset_vcpu(CPUState *cs)
542
 
-{
543
 
-    /* Feed the kernel back its initial register state */
544
 
-    ARMCPU *cpu = ARM_CPU(cs);
545
 
-
546
 
-    memmove(cpu->cpreg_values, cpu->cpreg_reset_values,
547
 
-            cpu->cpreg_array_len * sizeof(cpu->cpreg_values[0]));
548
 
-
549
 
-    if (!write_list_to_kvmstate(cpu)) {
550
 
-        abort();
551
 
-    }
552
 
-}
553
 
-
554
 
 bool kvm_arch_stop_on_emulation_error(CPUState *cs)
555
 
 {
556
 
     return true;
557
 
diff --git a/target-arm/kvm32.c b/target-arm/kvm32.c
558
 
new file mode 100644
559
 
index 0000000..a4fde07
560
 
--- /dev/null
561
 
+++ b/target-arm/kvm32.c
562
 
@@ -0,0 +1,515 @@
563
 
+/*
564
 
+ * ARM implementation of KVM hooks, 32 bit specific code.
565
 
+ *
566
 
+ * Copyright Christoffer Dall 2009-2010
567
 
+ *
568
 
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
569
 
+ * See the COPYING file in the top-level directory.
570
 
+ *
571
 
+ */
572
 
+
573
 
+#include <stdio.h>
574
 
+#include <sys/types.h>
575
 
+#include <sys/ioctl.h>
576
 
+#include <sys/mman.h>
577
 
+
578
 
+#include <linux/kvm.h>
579
 
+
580
 
+#include "qemu-common.h"
581
 
+#include "qemu/timer.h"
582
 
+#include "sysemu/sysemu.h"
583
 
+#include "sysemu/kvm.h"
584
 
+#include "kvm_arm.h"
585
 
+#include "cpu.h"
586
 
+#include "hw/arm/arm.h"
587
 
+
588
 
+static inline void set_feature(uint64_t *features, int feature)
589
 
+{
590
 
+    *features |= 1ULL << feature;
591
 
+}
592
 
+
593
 
+bool kvm_arm_get_host_cpu_features(ARMHostCPUClass *ahcc)
594
 
+{
595
 
+    /* Identify the feature bits corresponding to the host CPU, and
596
 
+     * fill out the ARMHostCPUClass fields accordingly. To do this
597
 
+     * we have to create a scratch VM, create a single CPU inside it,
598
 
+     * and then query that CPU for the relevant ID registers.
599
 
+     */
600
 
+    int i, ret, fdarray[3];
601
 
+    uint32_t midr, id_pfr0, id_isar0, mvfr1;
602
 
+    uint64_t features = 0;
603
 
+    /* Old kernels may not know about the PREFERRED_TARGET ioctl: however
604
 
+     * we know these will only support creating one kind of guest CPU,
605
 
+     * which is its preferred CPU type.
606
 
+     */
607
 
+    static const uint32_t cpus_to_try[] = {
608
 
+        QEMU_KVM_ARM_TARGET_CORTEX_A15,
609
 
+        QEMU_KVM_ARM_TARGET_NONE
610
 
+    };
611
 
+    struct kvm_vcpu_init init;
612
 
+    struct kvm_one_reg idregs[] = {
613
 
+        {
614
 
+            .id = KVM_REG_ARM | KVM_REG_SIZE_U32
615
 
+            | ENCODE_CP_REG(15, 0, 0, 0, 0, 0),
616
 
+            .addr = (uintptr_t)&midr,
617
 
+        },
618
 
+        {
619
 
+            .id = KVM_REG_ARM | KVM_REG_SIZE_U32
620
 
+            | ENCODE_CP_REG(15, 0, 0, 1, 0, 0),
621
 
+            .addr = (uintptr_t)&id_pfr0,
622
 
+        },
623
 
+        {
624
 
+            .id = KVM_REG_ARM | KVM_REG_SIZE_U32
625
 
+            | ENCODE_CP_REG(15, 0, 0, 2, 0, 0),
626
 
+            .addr = (uintptr_t)&id_isar0,
627
 
+        },
628
 
+        {
629
 
+            .id = KVM_REG_ARM | KVM_REG_SIZE_U32
630
 
+            | KVM_REG_ARM_VFP | KVM_REG_ARM_VFP_MVFR1,
631
 
+            .addr = (uintptr_t)&mvfr1,
632
 
+        },
633
 
+    };
634
 
+
635
 
+    if (!kvm_arm_create_scratch_host_vcpu(cpus_to_try, fdarray, &init)) {
636
 
+        return false;
637
 
+    }
638
 
+
639
 
+    ahcc->target = init.target;
640
 
+
641
 
+    /* This is not strictly blessed by the device tree binding docs yet,
642
 
+     * but in practice the kernel does not care about this string so
643
 
+     * there is no point maintaining an KVM_ARM_TARGET_* -> string table.
644
 
+     */
645
 
+    ahcc->dtb_compatible = "arm,arm-v7";
646
 
+
647
 
+    for (i = 0; i < ARRAY_SIZE(idregs); i++) {
648
 
+        ret = ioctl(fdarray[2], KVM_GET_ONE_REG, &idregs[i]);
649
 
+        if (ret) {
650
 
+            break;
651
 
+        }
652
 
+    }
653
 
+
654
 
+    kvm_arm_destroy_scratch_host_vcpu(fdarray);
655
 
+
656
 
+    if (ret) {
657
 
+        return false;
658
 
+    }
659
 
+
660
 
+    /* Now we've retrieved all the register information we can
661
 
+     * set the feature bits based on the ID register fields.
662
 
+     * We can assume any KVM supporting CPU is at least a v7
663
 
+     * with VFPv3, LPAE and the generic timers; this in turn implies
664
 
+     * most of the other feature bits, but a few must be tested.
665
 
+     */
666
 
+    set_feature(&features, ARM_FEATURE_V7);
667
 
+    set_feature(&features, ARM_FEATURE_VFP3);
668
 
+    set_feature(&features, ARM_FEATURE_LPAE);
669
 
+    set_feature(&features, ARM_FEATURE_GENERIC_TIMER);
670
 
+
671
 
+    switch (extract32(id_isar0, 24, 4)) {
672
 
+    case 1:
673
 
+        set_feature(&features, ARM_FEATURE_THUMB_DIV);
674
 
+        break;
675
 
+    case 2:
676
 
+        set_feature(&features, ARM_FEATURE_ARM_DIV);
677
 
+        set_feature(&features, ARM_FEATURE_THUMB_DIV);
678
 
+        break;
679
 
+    default:
680
 
+        break;
681
 
+    }
682
 
+
683
 
+    if (extract32(id_pfr0, 12, 4) == 1) {
684
 
+        set_feature(&features, ARM_FEATURE_THUMB2EE);
685
 
+    }
686
 
+    if (extract32(mvfr1, 20, 4) == 1) {
687
 
+        set_feature(&features, ARM_FEATURE_VFP_FP16);
688
 
+    }
689
 
+    if (extract32(mvfr1, 12, 4) == 1) {
690
 
+        set_feature(&features, ARM_FEATURE_NEON);
691
 
+    }
692
 
+    if (extract32(mvfr1, 28, 4) == 1) {
693
 
+        /* FMAC support implies VFPv4 */
694
 
+        set_feature(&features, ARM_FEATURE_VFP4);
695
 
+    }
696
 
+
697
 
+    ahcc->features = features;
698
 
+
699
 
+    return true;
700
 
+}
701
 
+
702
 
+static bool reg_syncs_via_tuple_list(uint64_t regidx)
703
 
+{
704
 
+    /* Return true if the regidx is a register we should synchronize
705
 
+     * via the cpreg_tuples array (ie is not a core reg we sync by
706
 
+     * hand in kvm_arch_get/put_registers())
707
 
+     */
708
 
+    switch (regidx & KVM_REG_ARM_COPROC_MASK) {
709
 
+    case KVM_REG_ARM_CORE:
710
 
+    case KVM_REG_ARM_VFP:
711
 
+        return false;
712
 
+    default:
713
 
+        return true;
714
 
+    }
715
 
+}
716
 
+
717
 
+static int compare_u64(const void *a, const void *b)
718
 
+{
719
 
+    if (*(uint64_t *)a > *(uint64_t *)b) {
720
 
+        return 1;
721
 
+    }
722
 
+    if (*(uint64_t *)a < *(uint64_t *)b) {
723
 
+        return -1;
724
 
+    }
725
 
+    return 0;
726
 
+}
727
 
+
728
 
+int kvm_arch_init_vcpu(CPUState *cs)
729
 
+{
730
 
+    struct kvm_vcpu_init init;
731
 
+    int i, ret, arraylen;
732
 
+    uint64_t v;
733
 
+    struct kvm_one_reg r;
734
 
+    struct kvm_reg_list rl;
735
 
+    struct kvm_reg_list *rlp;
736
 
+    ARMCPU *cpu = ARM_CPU(cs);
737
 
+
738
 
+    if (cpu->kvm_target == QEMU_KVM_ARM_TARGET_NONE) {
739
 
+        fprintf(stderr, "KVM is not supported for this guest CPU type\n");
740
 
+        return -EINVAL;
741
 
+    }
742
 
+
743
 
+    init.target = cpu->kvm_target;
744
 
+    memset(init.features, 0, sizeof(init.features));
745
 
+    if (cpu->start_powered_off) {
746
 
+        init.features[0] = 1 << KVM_ARM_VCPU_POWER_OFF;
747
 
+    }
748
 
+    ret = kvm_vcpu_ioctl(cs, KVM_ARM_VCPU_INIT, &init);
749
 
+    if (ret) {
750
 
+        return ret;
751
 
+    }
752
 
+    /* Query the kernel to make sure it supports 32 VFP
753
 
+     * registers: QEMU's "cortex-a15" CPU is always a
754
 
+     * VFP-D32 core. The simplest way to do this is just
755
 
+     * to attempt to read register d31.
756
 
+     */
757
 
+    r.id = KVM_REG_ARM | KVM_REG_SIZE_U64 | KVM_REG_ARM_VFP | 31;
758
 
+    r.addr = (uintptr_t)(&v);
759
 
+    ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &r);
760
 
+    if (ret == -ENOENT) {
761
 
+        return -EINVAL;
762
 
+    }
763
 
+
764
 
+    /* Populate the cpreg list based on the kernel's idea
765
 
+     * of what registers exist (and throw away the TCG-created list).
766
 
+     */
767
 
+    rl.n = 0;
768
 
+    ret = kvm_vcpu_ioctl(cs, KVM_GET_REG_LIST, &rl);
769
 
+    if (ret != -E2BIG) {
770
 
+        return ret;
771
 
+    }
772
 
+    rlp = g_malloc(sizeof(struct kvm_reg_list) + rl.n * sizeof(uint64_t));
773
 
+    rlp->n = rl.n;
774
 
+    ret = kvm_vcpu_ioctl(cs, KVM_GET_REG_LIST, rlp);
775
 
+    if (ret) {
776
 
+        goto out;
777
 
+    }
778
 
+    /* Sort the list we get back from the kernel, since cpreg_tuples
779
 
+     * must be in strictly ascending order.
780
 
+     */
781
 
+    qsort(&rlp->reg, rlp->n, sizeof(rlp->reg[0]), compare_u64);
782
 
+
783
 
+    for (i = 0, arraylen = 0; i < rlp->n; i++) {
784
 
+        if (!reg_syncs_via_tuple_list(rlp->reg[i])) {
785
 
+            continue;
786
 
+        }
787
 
+        switch (rlp->reg[i] & KVM_REG_SIZE_MASK) {
788
 
+        case KVM_REG_SIZE_U32:
789
 
+        case KVM_REG_SIZE_U64:
790
 
+            break;
791
 
+        default:
792
 
+            fprintf(stderr, "Can't handle size of register in kernel list\n");
793
 
+            ret = -EINVAL;
794
 
+            goto out;
795
 
+        }
796
 
+
797
 
+        arraylen++;
798
 
+    }
799
 
+
800
 
+    cpu->cpreg_indexes = g_renew(uint64_t, cpu->cpreg_indexes, arraylen);
801
 
+    cpu->cpreg_values = g_renew(uint64_t, cpu->cpreg_values, arraylen);
802
 
+    cpu->cpreg_vmstate_indexes = g_renew(uint64_t, cpu->cpreg_vmstate_indexes,
803
 
+                                         arraylen);
804
 
+    cpu->cpreg_vmstate_values = g_renew(uint64_t, cpu->cpreg_vmstate_values,
805
 
+                                        arraylen);
806
 
+    cpu->cpreg_array_len = arraylen;
807
 
+    cpu->cpreg_vmstate_array_len = arraylen;
808
 
+
809
 
+    for (i = 0, arraylen = 0; i < rlp->n; i++) {
810
 
+        uint64_t regidx = rlp->reg[i];
811
 
+        if (!reg_syncs_via_tuple_list(regidx)) {
812
 
+            continue;
813
 
+        }
814
 
+        cpu->cpreg_indexes[arraylen] = regidx;
815
 
+        arraylen++;
816
 
+    }
817
 
+    assert(cpu->cpreg_array_len == arraylen);
818
 
+
819
 
+    if (!write_kvmstate_to_list(cpu)) {
820
 
+        /* Shouldn't happen unless kernel is inconsistent about
821
 
+         * what registers exist.
822
 
+         */
823
 
+        fprintf(stderr, "Initial read of kernel register state failed\n");
824
 
+        ret = -EINVAL;
825
 
+        goto out;
826
 
+    }
827
 
+
828
 
+    /* Save a copy of the initial register values so that we can
829
 
+     * feed it back to the kernel on VCPU reset.
830
 
+     */
831
 
+    cpu->cpreg_reset_values = g_memdup(cpu->cpreg_values,
832
 
+                                       cpu->cpreg_array_len *
833
 
+                                       sizeof(cpu->cpreg_values[0]));
834
 
+
835
 
+out:
836
 
+    g_free(rlp);
837
 
+    return ret;
838
 
+}
839
 
+
840
 
+typedef struct Reg {
841
 
+    uint64_t id;
842
 
+    int offset;
843
 
+} Reg;
844
 
+
845
 
+#define COREREG(KERNELNAME, QEMUFIELD)                       \
846
 
+    {                                                        \
847
 
+        KVM_REG_ARM | KVM_REG_SIZE_U32 |                     \
848
 
+        KVM_REG_ARM_CORE | KVM_REG_ARM_CORE_REG(KERNELNAME), \
849
 
+        offsetof(CPUARMState, QEMUFIELD)                     \
850
 
+    }
851
 
+
852
 
+#define VFPSYSREG(R)                                       \
853
 
+    {                                                      \
854
 
+        KVM_REG_ARM | KVM_REG_SIZE_U32 | KVM_REG_ARM_VFP | \
855
 
+        KVM_REG_ARM_VFP_##R,                               \
856
 
+        offsetof(CPUARMState, vfp.xregs[ARM_VFP_##R])      \
857
 
+    }
858
 
+
859
 
+static const Reg regs[] = {
860
 
+    /* R0_usr .. R14_usr */
861
 
+    COREREG(usr_regs.uregs[0], regs[0]),
862
 
+    COREREG(usr_regs.uregs[1], regs[1]),
863
 
+    COREREG(usr_regs.uregs[2], regs[2]),
864
 
+    COREREG(usr_regs.uregs[3], regs[3]),
865
 
+    COREREG(usr_regs.uregs[4], regs[4]),
866
 
+    COREREG(usr_regs.uregs[5], regs[5]),
867
 
+    COREREG(usr_regs.uregs[6], regs[6]),
868
 
+    COREREG(usr_regs.uregs[7], regs[7]),
869
 
+    COREREG(usr_regs.uregs[8], usr_regs[0]),
870
 
+    COREREG(usr_regs.uregs[9], usr_regs[1]),
871
 
+    COREREG(usr_regs.uregs[10], usr_regs[2]),
872
 
+    COREREG(usr_regs.uregs[11], usr_regs[3]),
873
 
+    COREREG(usr_regs.uregs[12], usr_regs[4]),
874
 
+    COREREG(usr_regs.uregs[13], banked_r13[0]),
875
 
+    COREREG(usr_regs.uregs[14], banked_r14[0]),
876
 
+    /* R13, R14, SPSR for SVC, ABT, UND, IRQ banks */
877
 
+    COREREG(svc_regs[0], banked_r13[1]),
878
 
+    COREREG(svc_regs[1], banked_r14[1]),
879
 
+    COREREG(svc_regs[2], banked_spsr[1]),
880
 
+    COREREG(abt_regs[0], banked_r13[2]),
881
 
+    COREREG(abt_regs[1], banked_r14[2]),
882
 
+    COREREG(abt_regs[2], banked_spsr[2]),
883
 
+    COREREG(und_regs[0], banked_r13[3]),
884
 
+    COREREG(und_regs[1], banked_r14[3]),
885
 
+    COREREG(und_regs[2], banked_spsr[3]),
886
 
+    COREREG(irq_regs[0], banked_r13[4]),
887
 
+    COREREG(irq_regs[1], banked_r14[4]),
888
 
+    COREREG(irq_regs[2], banked_spsr[4]),
889
 
+    /* R8_fiq .. R14_fiq and SPSR_fiq */
890
 
+    COREREG(fiq_regs[0], fiq_regs[0]),
891
 
+    COREREG(fiq_regs[1], fiq_regs[1]),
892
 
+    COREREG(fiq_regs[2], fiq_regs[2]),
893
 
+    COREREG(fiq_regs[3], fiq_regs[3]),
894
 
+    COREREG(fiq_regs[4], fiq_regs[4]),
895
 
+    COREREG(fiq_regs[5], banked_r13[5]),
896
 
+    COREREG(fiq_regs[6], banked_r14[5]),
897
 
+    COREREG(fiq_regs[7], banked_spsr[5]),
898
 
+    /* R15 */
899
 
+    COREREG(usr_regs.uregs[15], regs[15]),
900
 
+    /* VFP system registers */
901
 
+    VFPSYSREG(FPSID),
902
 
+    VFPSYSREG(MVFR1),
903
 
+    VFPSYSREG(MVFR0),
904
 
+    VFPSYSREG(FPEXC),
905
 
+    VFPSYSREG(FPINST),
906
 
+    VFPSYSREG(FPINST2),
907
 
+};
908
 
+
909
 
+int kvm_arch_put_registers(CPUState *cs, int level)
910
 
+{
911
 
+    ARMCPU *cpu = ARM_CPU(cs);
912
 
+    CPUARMState *env = &cpu->env;
913
 
+    struct kvm_one_reg r;
914
 
+    int mode, bn;
915
 
+    int ret, i;
916
 
+    uint32_t cpsr, fpscr;
917
 
+
918
 
+    /* Make sure the banked regs are properly set */
919
 
+    mode = env->uncached_cpsr & CPSR_M;
920
 
+    bn = bank_number(mode);
921
 
+    if (mode == ARM_CPU_MODE_FIQ) {
922
 
+        memcpy(env->fiq_regs, env->regs + 8, 5 * sizeof(uint32_t));
923
 
+    } else {
924
 
+        memcpy(env->usr_regs, env->regs + 8, 5 * sizeof(uint32_t));
925
 
+    }
926
 
+    env->banked_r13[bn] = env->regs[13];
927
 
+    env->banked_r14[bn] = env->regs[14];
928
 
+    env->banked_spsr[bn] = env->spsr;
929
 
+
930
 
+    /* Now we can safely copy stuff down to the kernel */
931
 
+    for (i = 0; i < ARRAY_SIZE(regs); i++) {
932
 
+        r.id = regs[i].id;
933
 
+        r.addr = (uintptr_t)(env) + regs[i].offset;
934
 
+        ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &r);
935
 
+        if (ret) {
936
 
+            return ret;
937
 
+        }
938
 
+    }
939
 
+
940
 
+    /* Special cases which aren't a single CPUARMState field */
941
 
+    cpsr = cpsr_read(env);
942
 
+    r.id = KVM_REG_ARM | KVM_REG_SIZE_U32 |
943
 
+        KVM_REG_ARM_CORE | KVM_REG_ARM_CORE_REG(usr_regs.ARM_cpsr);
944
 
+    r.addr = (uintptr_t)(&cpsr);
945
 
+    ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &r);
946
 
+    if (ret) {
947
 
+        return ret;
948
 
+    }
949
 
+
950
 
+    /* VFP registers */
951
 
+    r.id = KVM_REG_ARM | KVM_REG_SIZE_U64 | KVM_REG_ARM_VFP;
952
 
+    for (i = 0; i < 32; i++) {
953
 
+        r.addr = (uintptr_t)(&env->vfp.regs[i]);
954
 
+        ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &r);
955
 
+        if (ret) {
956
 
+            return ret;
957
 
+        }
958
 
+        r.id++;
959
 
+    }
960
 
+
961
 
+    r.id = KVM_REG_ARM | KVM_REG_SIZE_U32 | KVM_REG_ARM_VFP |
962
 
+        KVM_REG_ARM_VFP_FPSCR;
963
 
+    fpscr = vfp_get_fpscr(env);
964
 
+    r.addr = (uintptr_t)&fpscr;
965
 
+    ret = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &r);
966
 
+    if (ret) {
967
 
+        return ret;
968
 
+    }
969
 
+
970
 
+    /* Note that we do not call write_cpustate_to_list()
971
 
+     * here, so we are only writing the tuple list back to
972
 
+     * KVM. This is safe because nothing can change the
973
 
+     * CPUARMState cp15 fields (in particular gdb accesses cannot)
974
 
+     * and so there are no changes to sync. In fact syncing would
975
 
+     * be wrong at this point: for a constant register where TCG and
976
 
+     * KVM disagree about its value, the preceding write_list_to_cpustate()
977
 
+     * would not have had any effect on the CPUARMState value (since the
978
 
+     * register is read-only), and a write_cpustate_to_list() here would
979
 
+     * then try to write the TCG value back into KVM -- this would either
980
 
+     * fail or incorrectly change the value the guest sees.
981
 
+     *
982
 
+     * If we ever want to allow the user to modify cp15 registers via
983
 
+     * the gdb stub, we would need to be more clever here (for instance
984
 
+     * tracking the set of registers kvm_arch_get_registers() successfully
985
 
+     * managed to update the CPUARMState with, and only allowing those
986
 
+     * to be written back up into the kernel).
987
 
+     */
988
 
+    if (!write_list_to_kvmstate(cpu)) {
989
 
+        return EINVAL;
990
 
+    }
991
 
+
992
 
+    return ret;
993
 
+}
994
 
+
995
 
+int kvm_arch_get_registers(CPUState *cs)
996
 
+{
997
 
+    ARMCPU *cpu = ARM_CPU(cs);
998
 
+    CPUARMState *env = &cpu->env;
999
 
+    struct kvm_one_reg r;
1000
 
+    int mode, bn;
1001
 
+    int ret, i;
1002
 
+    uint32_t cpsr, fpscr;
1003
 
+
1004
 
+    for (i = 0; i < ARRAY_SIZE(regs); i++) {
1005
 
+        r.id = regs[i].id;
1006
 
+        r.addr = (uintptr_t)(env) + regs[i].offset;
1007
 
+        ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &r);
1008
 
+        if (ret) {
1009
 
+            return ret;
1010
 
+        }
1011
 
+    }
1012
 
+
1013
 
+    /* Special cases which aren't a single CPUARMState field */
1014
 
+    r.id = KVM_REG_ARM | KVM_REG_SIZE_U32 |
1015
 
+        KVM_REG_ARM_CORE | KVM_REG_ARM_CORE_REG(usr_regs.ARM_cpsr);
1016
 
+    r.addr = (uintptr_t)(&cpsr);
1017
 
+    ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &r);
1018
 
+    if (ret) {
1019
 
+        return ret;
1020
 
+    }
1021
 
+    cpsr_write(env, cpsr, 0xffffffff);
1022
 
+
1023
 
+    /* Make sure the current mode regs are properly set */
1024
 
+    mode = env->uncached_cpsr & CPSR_M;
1025
 
+    bn = bank_number(mode);
1026
 
+    if (mode == ARM_CPU_MODE_FIQ) {
1027
 
+        memcpy(env->regs + 8, env->fiq_regs, 5 * sizeof(uint32_t));
1028
 
+    } else {
1029
 
+        memcpy(env->regs + 8, env->usr_regs, 5 * sizeof(uint32_t));
1030
 
+    }
1031
 
+    env->regs[13] = env->banked_r13[bn];
1032
 
+    env->regs[14] = env->banked_r14[bn];
1033
 
+    env->spsr = env->banked_spsr[bn];
1034
 
+
1035
 
+    /* VFP registers */
1036
 
+    r.id = KVM_REG_ARM | KVM_REG_SIZE_U64 | KVM_REG_ARM_VFP;
1037
 
+    for (i = 0; i < 32; i++) {
1038
 
+        r.addr = (uintptr_t)(&env->vfp.regs[i]);
1039
 
+        ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &r);
1040
 
+        if (ret) {
1041
 
+            return ret;
1042
 
+        }
1043
 
+        r.id++;
1044
 
+    }
1045
 
+
1046
 
+    r.id = KVM_REG_ARM | KVM_REG_SIZE_U32 | KVM_REG_ARM_VFP |
1047
 
+        KVM_REG_ARM_VFP_FPSCR;
1048
 
+    r.addr = (uintptr_t)&fpscr;
1049
 
+    ret = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &r);
1050
 
+    if (ret) {
1051
 
+        return ret;
1052
 
+    }
1053
 
+    vfp_set_fpscr(env, fpscr);
1054
 
+
1055
 
+    if (!write_kvmstate_to_list(cpu)) {
1056
 
+        return EINVAL;
1057
 
+    }
1058
 
+    /* Note that it's OK to have registers which aren't in CPUState,
1059
 
+     * so we can ignore a failure return here.
1060
 
+     */
1061
 
+    write_list_to_cpustate(cpu);
1062
 
+
1063
 
+    return 0;
1064
 
+}
1065
 
+
1066
 
+void kvm_arch_reset_vcpu(CPUState *cs)
1067
 
+{
1068
 
+    /* Feed the kernel back its initial register state */
1069
 
+    ARMCPU *cpu = ARM_CPU(cs);
1070
 
+
1071
 
+    memmove(cpu->cpreg_values, cpu->cpreg_reset_values,
1072
 
+            cpu->cpreg_array_len * sizeof(cpu->cpreg_values[0]));
1073
 
+
1074
 
+    if (!write_list_to_kvmstate(cpu)) {
1075
 
+        abort();
1076
 
+    }
1077
 
+}
1078
 
1.8.5.2
1079