← Back to branch summary

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

« back to all changes in this revision

Viewing changes to debian/patches/ubuntu/linaro/0060-target-arm-add-support-for-smc.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/ubuntu/linaro/0060-target-arm-add-support-for-smc.patch
 
1
From e02ac60868c370ec9a5464bfa4d65cf867f0f679 Mon Sep 17 00:00:00 2001
 
2
From: Peter Maydell <peter.maydell@linaro.org>
 
3
Date: Mon, 18 Feb 2013 16:58:34 +0000
 
4
Subject: [PATCH 60/70] target-arm: add support for smc
 
5
 
 
6
---
 
7
 target-arm/cpu.h       |  9 +++++---
 
8
 target-arm/helper.c    | 58 +++++++++++++++++++++++++++++++++-----------------
 
9
 target-arm/machine.c   |  6 +++---
 
10
 target-arm/translate.c | 47 ++++++++++++++++++++++++++++++----------
 
11
 4 files changed, 83 insertions(+), 37 deletions(-)
 
12
 
 
13
diff --git a/target-arm/cpu.h b/target-arm/cpu.h
 
14
index 0f8cb4e..8c9f6a8 100644
 
15
--- a/target-arm/cpu.h
 
16
+++ b/target-arm/cpu.h
 
17
@@ -49,6 +49,7 @@
 
18
 #define EXCP_EXCEPTION_EXIT  8   /* Return from v7M exception.  */
 
19
 #define EXCP_KERNEL_TRAP     9   /* Jumped to kernel code page.  */
 
20
 #define EXCP_STREX          10
 
21
+#define EXCP_SMC            11   /* secure monitor call */
 
22
 
 
23
 #define ARMV7M_EXCP_RESET   1
 
24
 #define ARMV7M_EXCP_NMI     2
 
25
@@ -124,9 +125,9 @@ typedef struct CPUARMState {
 
26
     uint32_t spsr;
 
27
 
 
28
     /* Banked registers.  */
 
29
-    uint32_t banked_spsr[6];
 
30
-    uint32_t banked_r13[6];
 
31
-    uint32_t banked_r14[6];
 
32
+    uint32_t banked_spsr[7];
 
33
+    uint32_t banked_r13[7];
 
34
+    uint32_t banked_r14[7];
 
35
 
 
36
     /* These hold r8-r12.  */
 
37
     uint32_t usr_regs[5];
 
38
@@ -179,6 +180,7 @@ typedef struct CPUARMState {
 
39
         uint32_t c9_pmuserenr; /* perf monitor user enable */
 
40
         uint32_t c9_pminten; /* perf monitor interrupt enables */
 
41
         uint32_t c12_vbar; /* vector base address register */
 
42
+        uint32_t c12_mvbar; /* monitor vector base address register. */
 
43
         uint32_t c13_fcse; /* FCSE PID.  */
 
44
         uint32_t c13_context; /* Context ID.  */
 
45
         uint32_t c13_tls1; /* User RW Thread register.  */
 
46
@@ -404,6 +406,7 @@ enum arm_cpu_mode {
 
47
   ARM_CPU_MODE_FIQ = 0x11,
 
48
   ARM_CPU_MODE_IRQ = 0x12,
 
49
   ARM_CPU_MODE_SVC = 0x13,
 
50
+  ARM_CPU_MODE_SMC = 0x16,
 
51
   ARM_CPU_MODE_ABT = 0x17,
 
52
   ARM_CPU_MODE_UND = 0x1b,
 
53
   ARM_CPU_MODE_SYS = 0x1f
 
54
diff --git a/target-arm/helper.c b/target-arm/helper.c
 
55
index c4633be..9ff9699 100644
 
56
--- a/target-arm/helper.c
 
57
+++ b/target-arm/helper.c
 
58
@@ -543,13 +543,6 @@ static int pmintenclr_write(CPUARMState *env, const ARMCPRegInfo *ri,
 
59
     return 0;
 
60
 }
 
61
 
 
62
-static int vbar_write(CPUARMState *env, const ARMCPRegInfo *ri,
 
63
-                      uint64_t value)
 
64
-{
 
65
-    env->cp15.c12_vbar = value & ~0x1Ful;
 
66
-    return 0;
 
67
-}
 
68
-
 
69
 static int ccsidr_read(CPUARMState *env, const ARMCPRegInfo *ri,
 
70
                        uint64_t *value)
 
71
 {
 
72
@@ -1510,6 +1503,12 @@ static const ARMCPRegInfo lpae_cp_reginfo[] = {
 
73
     REGINFO_SENTINEL
 
74
 };
 
75
 
 
76
+static int vbar_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value)
 
77
+{
 
78
+    CPREG_FIELD32(env, ri) = value & ~0x1f;
 
79
+    return 0;
 
80
+}
 
81
+
 
82
 static const ARMCPRegInfo trustzone_cp_reginfo[] = {
 
83
     /* Dummy implementations of registers; we don't enforce the
 
84
      * 'secure mode only' access checks. TODO: revisit as part of
 
85
@@ -1529,7 +1528,8 @@ static const ARMCPRegInfo trustzone_cp_reginfo[] = {
 
86
       .fieldoffset = offsetof(CPUARMState, cp15.c12_vbar),
 
87
       .resetvalue = 0 },
 
88
     { .name = "MVBAR", .cp = 15, .crn = 12, .crm = 0, .opc1 = 0, .opc2 = 1,
 
89
-      .access = PL1_RW, .type = ARM_CP_CONST, .resetvalue = 0 },
 
90
+      .access = PL1_RW, .fieldoffset = offsetof(CPUARMState, cp15.c12_mvbar),
 
91
+      .writefn = vbar_write, .resetvalue = 0 },
 
92
     REGINFO_SENTINEL
 
93
 };
 
94
 
 
95
@@ -2204,6 +2204,8 @@ int bank_number(int mode)
 
96
         return 4;
 
97
     case ARM_CPU_MODE_FIQ:
 
98
         return 5;
 
99
+    case ARM_CPU_MODE_SMC:
 
100
+        return 6;
 
101
     }
 
102
     hw_error("bank number requested for bad CPSR mode value 0x%x\n", mode);
 
103
 }
 
104
@@ -2500,23 +2502,39 @@ void arm_cpu_do_interrupt(CPUState *cs)
 
105
         mask = CPSR_A | CPSR_I | CPSR_F;
 
106
         offset = 4;
 
107
         break;
 
108
+    case EXCP_SMC:
 
109
+        if (semihosting_enabled) {
 
110
+            cpu_abort(env, "SMC handling under semihosting not implemented\n");
 
111
+            return;
 
112
+        }
 
113
+        if ((env->uncached_cpsr & CPSR_M) == ARM_CPU_MODE_SMC) {
 
114
+            env->cp15.c1_scr &= ~1;
 
115
+        }
 
116
+        offset = env->thumb ? 2 : 0;
 
117
+        new_mode = ARM_CPU_MODE_SMC;
 
118
+        addr = 0x08;
 
119
+        mask = CPSR_A | CPSR_I | CPSR_F;
 
120
+        break;
 
121
     default:
 
122
         cpu_abort(env, "Unhandled exception 0x%x\n", env->exception_index);
 
123
         return; /* Never happens.  Keep compiler happy.  */
 
124
     }
 
125
-    /* High vectors.  */
 
126
-    if (env->cp15.c1_sys & (1 << 13)) {
 
127
-        /* when enabled, base address cannot be remapped.  */
 
128
-        addr += 0xffff0000;
 
129
+    if (arm_feature(env, ARM_FEATURE_TRUSTZONE)) {
 
130
+        if (new_mode == ARM_CPU_MODE_SMC ||
 
131
+            (env->uncached_cpsr & CPSR_M) == ARM_CPU_MODE_SMC) {
 
132
+            addr += env->cp15.c12_mvbar;
 
133
+        } else {
 
134
+            if (env->cp15.c1_sys & (1 << 13)) {
 
135
+                addr += 0xffff0000;
 
136
+            } else {
 
137
+                addr += env->cp15.c12_vbar;
 
138
+            }
 
139
+        }
 
140
     } else {
 
141
-        /* ARM v7 architectures provide a vector base address register to remap
 
142
-         * the interrupt vector table.
 
143
-         * This register is only followed in non-monitor mode, and has a secure
 
144
-         * and un-secure copy. Since the cpu is always in a un-secure operation
 
145
-         * and is never in monitor mode this feature is always active.
 
146
-         * Note: only bits 31:5 are valid.
 
147
-         */
 
148
-        addr += env->cp15.c12_vbar;
 
149
+        /* High vectors.  */
 
150
+        if (env->cp15.c1_sys & (1 << 13)) {
 
151
+            addr += 0xffff0000;
 
152
+        }
 
153
     }
 
154
     switch_mode (env, new_mode);
 
155
     env->spsr = cpsr_read(env);
 
156
diff --git a/target-arm/machine.c b/target-arm/machine.c
 
157
index 74f010f..3a41dd0 100644
 
158
--- a/target-arm/machine.c
 
159
+++ b/target-arm/machine.c
 
160
@@ -238,9 +238,9 @@ const VMStateDescription vmstate_arm_cpu = {
 
161
             .offset = 0,
 
162
         },
 
163
         VMSTATE_UINT32(env.spsr, ARMCPU),
 
164
-        VMSTATE_UINT32_ARRAY(env.banked_spsr, ARMCPU, 6),
 
165
-        VMSTATE_UINT32_ARRAY(env.banked_r13, ARMCPU, 6),
 
166
-        VMSTATE_UINT32_ARRAY(env.banked_r14, ARMCPU, 6),
 
167
+        VMSTATE_UINT32_ARRAY(env.banked_spsr, ARMCPU, 7),
 
168
+        VMSTATE_UINT32_ARRAY(env.banked_r13, ARMCPU, 7),
 
169
+        VMSTATE_UINT32_ARRAY(env.banked_r14, ARMCPU, 7),
 
170
         VMSTATE_UINT32_ARRAY(env.usr_regs, ARMCPU, 5),
 
171
         VMSTATE_UINT32_ARRAY(env.fiq_regs, ARMCPU, 5),
 
172
         /* The length-check must come before the arrays to avoid
 
173
diff --git a/target-arm/translate.c b/target-arm/translate.c
 
174
index 5f003e7..6954b56 100644
 
175
--- a/target-arm/translate.c
 
176
+++ b/target-arm/translate.c
 
177
@@ -60,6 +60,7 @@ static uint32_t gen_opc_condexec_bits[OPC_BUF_SIZE];
 
178
    conditional execution state has been updated.  */
 
179
 #define DISAS_WFI 4
 
180
 #define DISAS_SWI 5
 
181
+#define DISAS_SMC 6
 
182
 
 
183
 TCGv_ptr cpu_env;
 
184
 /* We reuse the same 64-bit temporaries for efficiency.  */
 
185
@@ -904,6 +905,12 @@ DO_GEN_ST(st8)
 
186
 DO_GEN_ST(st16)
 
187
 DO_GEN_ST(st32)
 
188
 
 
189
+static inline void gen_smc(CPUARMState *env, DisasContext *s)
 
190
+{
 
191
+    tcg_gen_movi_i32(cpu_R[15], s->pc);
 
192
+    s->is_jmp = DISAS_SMC;
 
193
+}
 
194
+
 
195
 static inline void gen_set_pc_im(DisasContext *s, target_ulong val)
 
196
 {
 
197
     if (s->aarch64) {
 
198
@@ -6878,8 +6885,13 @@ static void disas_arm_insn(CPUARMState * env, DisasContext *s)
 
199
         } else if ((insn & 0x0fe00000) == 0x0c400000) {
 
200
             /* Coprocessor double register transfer.  */
 
201
             ARCH(5TE);
 
202
+            /* XXX doesn't belong in the trustzone patch: should just UNDEF? */
 
203
+            cpu_abort(env, "unsupported coprocessor double register transfer\n");
 
204
         } else if ((insn & 0x0f000010) == 0x0e000010) {
 
205
             /* Additional coprocessor register transfer.  */
 
206
+            if (!disas_coproc_insn(env, s, insn)) {
 
207
+                return;
 
208
+            }
 
209
         } else if ((insn & 0x0ff10020) == 0x01000000) {
 
210
             uint32_t mask;
 
211
             uint32_t val;
 
212
@@ -7030,15 +7042,19 @@ static void disas_arm_insn(CPUARMState * env, DisasContext *s)
 
213
             store_reg(s, rd, tmp);
 
214
             break;
 
215
         case 7:
 
216
-            /* SMC instruction (op1 == 3)
 
217
-               and undefined instructions (op1 == 0 || op1 == 2)
 
218
-               will trap */
 
219
-            if (op1 != 1) {
 
220
+            if (op1 == 1) {
 
221
+                /* bkpt */
 
222
+                ARCH(5);
 
223
+                gen_exception_insn(s, 4, EXCP_BKPT);
 
224
+            } else if (op1 == 3) {
 
225
+                /* smi/smc */
 
226
+                if (!arm_feature(env, ARM_FEATURE_TRUSTZONE) || IS_USER(s)) {
 
227
+                    goto illegal_op;
 
228
+                }
 
229
+                gen_smc(env, s);
 
230
+            } else {
 
231
                 goto illegal_op;
 
232
             }
 
233
-            /* bkpt */
 
234
-            ARCH(5);
 
235
-            gen_exception_insn(s, 4, EXCP_BKPT);
 
236
             break;
 
237
         case 0x8: /* signed multiply */
 
238
         case 0xa:
 
239
@@ -8808,10 +8824,12 @@ static int disas_thumb2_insn(CPUARMState *env, DisasContext *s, uint16_t insn_hw
 
240
                     goto illegal_op;
 
241
 
 
242
                 if (insn & (1 << 26)) {
 
243
-                    /* Secure monitor call (v6Z) */
 
244
-                    qemu_log_mask(LOG_UNIMP,
 
245
-                                  "arm: unimplemented secure monitor call\n");
 
246
-                    goto illegal_op; /* not implemented.  */
 
247
+                    /* Secure monitor call / smc (v6Z) */
 
248
+                    if (!arm_feature(env, ARM_FEATURE_TRUSTZONE)
 
249
+                        || IS_USER(s)) {
 
250
+                        goto illegal_op;
 
251
+                    }
 
252
+                    gen_smc(env, s);
 
253
                 } else {
 
254
                     op = (insn >> 20) & 7;
 
255
                     switch (op) {
 
256
@@ -10205,6 +10223,8 @@ static inline void gen_intermediate_code_internal(ARMCPU *cpu,
 
257
             gen_set_condexec(dc);
 
258
             if (dc->is_jmp == DISAS_SWI) {
 
259
                 gen_exception(EXCP_SWI);
 
260
+            } else if (dc->is_jmp == DISAS_SMC) {
 
261
+                gen_exception(EXCP_SMC);
 
262
             } else {
 
263
                 gen_exception(EXCP_DEBUG);
 
264
             }
 
265
@@ -10217,6 +10237,8 @@ static inline void gen_intermediate_code_internal(ARMCPU *cpu,
 
266
         gen_set_condexec(dc);
 
267
         if (dc->is_jmp == DISAS_SWI && !dc->condjmp) {
 
268
             gen_exception(EXCP_SWI);
 
269
+        } else if (dc->is_jmp == DISAS_SMC && !dc->condjmp) {
 
270
+            gen_exception(EXCP_SMC);
 
271
         } else {
 
272
             /* FIXME: Single stepping a WFI insn will not halt
 
273
                the CPU.  */
 
274
@@ -10251,6 +10273,9 @@ static inline void gen_intermediate_code_internal(ARMCPU *cpu,
 
275
         case DISAS_SWI:
 
276
             gen_exception(EXCP_SWI);
 
277
             break;
 
278
+        case DISAS_SMC:
 
279
+            gen_exception(EXCP_SMC);
 
280
+            break;
 
281
         }
 
282
         if (dc->condjmp) {
 
283
             gen_set_label(dc->condlabel);
 
284
-- 
 
285
1.8.5.2
 
286