]> git.proxmox.com Git - mirror_qemu.git/blob - target/i386/nvmm/nvmm-all.c
projects / mirror_qemu.git / blob
? search:


9f940413318c9d7d384f2735a0de91c5e17832af
[mirror_qemu.git] / target / i386 / nvmm / nvmm-all.c
1 /*
2 * Copyright (c) 2018-2019 Maxime Villard, All rights reserved.
3 *
4 * NetBSD Virtual Machine Monitor (NVMM) accelerator for QEMU.
5 *
6 * This work is licensed under the terms of the GNU GPL, version 2 or later.
7 * See the COPYING file in the top-level directory.
8 */
9
10 #include "qemu/osdep.h"
11 #include "cpu.h"
12 #include "exec/address-spaces.h"
13 #include "exec/ioport.h"
14 #include "qemu-common.h"
15 #include "qemu/accel.h"
16 #include "sysemu/nvmm.h"
17 #include "sysemu/cpus.h"
18 #include "sysemu/runstate.h"
19 #include "qemu/main-loop.h"
20 #include "qemu/error-report.h"
21 #include "qapi/error.h"
22 #include "qemu/queue.h"
23 #include "migration/blocker.h"
24 #include "strings.h"
25
26 #include "nvmm-accel-ops.h"
27
28 #include <nvmm.h>
29
30 struct qemu_vcpu {
31 struct nvmm_vcpu vcpu;
32 uint8_t tpr;
33 bool stop;
34
35 /* Window-exiting for INTs/NMIs. */
36 bool int_window_exit;
37 bool nmi_window_exit;
38
39 /* The guest is in an interrupt shadow (POP SS, etc). */
40 bool int_shadow;
41 };
42
43 struct qemu_machine {
44 struct nvmm_capability cap;
45 struct nvmm_machine mach;
46 };
47
48 /* -------------------------------------------------------------------------- */
49
50 static bool nvmm_allowed;
51 static struct qemu_machine qemu_mach;
52
53 static struct qemu_vcpu *
54 get_qemu_vcpu(CPUState *cpu)
55 {
56 return (struct qemu_vcpu *)cpu->hax_vcpu;
57 }
58
59 static struct nvmm_machine *
60 get_nvmm_mach(void)
61 {
62 return &qemu_mach.mach;
63 }
64
65 /* -------------------------------------------------------------------------- */
66
67 static void
68 nvmm_set_segment(struct nvmm_x64_state_seg *nseg, const SegmentCache *qseg)
69 {
70 uint32_t attrib = qseg->flags;
71
72 nseg->selector = qseg->selector;
73 nseg->limit = qseg->limit;
74 nseg->base = qseg->base;
75 nseg->attrib.type = __SHIFTOUT(attrib, DESC_TYPE_MASK);
76 nseg->attrib.s = __SHIFTOUT(attrib, DESC_S_MASK);
77 nseg->attrib.dpl = __SHIFTOUT(attrib, DESC_DPL_MASK);
78 nseg->attrib.p = __SHIFTOUT(attrib, DESC_P_MASK);
79 nseg->attrib.avl = __SHIFTOUT(attrib, DESC_AVL_MASK);
80 nseg->attrib.l = __SHIFTOUT(attrib, DESC_L_MASK);
81 nseg->attrib.def = __SHIFTOUT(attrib, DESC_B_MASK);
82 nseg->attrib.g = __SHIFTOUT(attrib, DESC_G_MASK);
83 }
84
85 static void
86 nvmm_set_registers(CPUState *cpu)
87 {
88 CPUX86State *env = cpu->env_ptr;
89 struct nvmm_machine *mach = get_nvmm_mach();
90 struct qemu_vcpu *qcpu = get_qemu_vcpu(cpu);
91 struct nvmm_vcpu *vcpu = &qcpu->vcpu;
92 struct nvmm_x64_state *state = vcpu->state;
93 uint64_t bitmap;
94 size_t i;
95 int ret;
96
97 assert(cpu_is_stopped(cpu) || qemu_cpu_is_self(cpu));
98
99 /* GPRs. */
100 state->gprs[NVMM_X64_GPR_RAX] = env->regs[R_EAX];
101 state->gprs[NVMM_X64_GPR_RCX] = env->regs[R_ECX];
102 state->gprs[NVMM_X64_GPR_RDX] = env->regs[R_EDX];
103 state->gprs[NVMM_X64_GPR_RBX] = env->regs[R_EBX];
104 state->gprs[NVMM_X64_GPR_RSP] = env->regs[R_ESP];
105 state->gprs[NVMM_X64_GPR_RBP] = env->regs[R_EBP];
106 state->gprs[NVMM_X64_GPR_RSI] = env->regs[R_ESI];
107 state->gprs[NVMM_X64_GPR_RDI] = env->regs[R_EDI];
108 #ifdef TARGET_X86_64
109 state->gprs[NVMM_X64_GPR_R8] = env->regs[R_R8];
110 state->gprs[NVMM_X64_GPR_R9] = env->regs[R_R9];
111 state->gprs[NVMM_X64_GPR_R10] = env->regs[R_R10];
112 state->gprs[NVMM_X64_GPR_R11] = env->regs[R_R11];
113 state->gprs[NVMM_X64_GPR_R12] = env->regs[R_R12];
114 state->gprs[NVMM_X64_GPR_R13] = env->regs[R_R13];
115 state->gprs[NVMM_X64_GPR_R14] = env->regs[R_R14];
116 state->gprs[NVMM_X64_GPR_R15] = env->regs[R_R15];
117 #endif
118
119 /* RIP and RFLAGS. */
120 state->gprs[NVMM_X64_GPR_RIP] = env->eip;
121 state->gprs[NVMM_X64_GPR_RFLAGS] = env->eflags;
122
123 /* Segments. */
124 nvmm_set_segment(&state->segs[NVMM_X64_SEG_CS], &env->segs[R_CS]);
125 nvmm_set_segment(&state->segs[NVMM_X64_SEG_DS], &env->segs[R_DS]);
126 nvmm_set_segment(&state->segs[NVMM_X64_SEG_ES], &env->segs[R_ES]);
127 nvmm_set_segment(&state->segs[NVMM_X64_SEG_FS], &env->segs[R_FS]);
128 nvmm_set_segment(&state->segs[NVMM_X64_SEG_GS], &env->segs[R_GS]);
129 nvmm_set_segment(&state->segs[NVMM_X64_SEG_SS], &env->segs[R_SS]);
130
131 /* Special segments. */
132 nvmm_set_segment(&state->segs[NVMM_X64_SEG_GDT], &env->gdt);
133 nvmm_set_segment(&state->segs[NVMM_X64_SEG_LDT], &env->ldt);
134 nvmm_set_segment(&state->segs[NVMM_X64_SEG_TR], &env->tr);
135 nvmm_set_segment(&state->segs[NVMM_X64_SEG_IDT], &env->idt);
136
137 /* Control registers. */
138 state->crs[NVMM_X64_CR_CR0] = env->cr[0];
139 state->crs[NVMM_X64_CR_CR2] = env->cr[2];
140 state->crs[NVMM_X64_CR_CR3] = env->cr[3];
141 state->crs[NVMM_X64_CR_CR4] = env->cr[4];
142 state->crs[NVMM_X64_CR_CR8] = qcpu->tpr;
143 state->crs[NVMM_X64_CR_XCR0] = env->xcr0;
144
145 /* Debug registers. */
146 state->drs[NVMM_X64_DR_DR0] = env->dr[0];
147 state->drs[NVMM_X64_DR_DR1] = env->dr[1];
148 state->drs[NVMM_X64_DR_DR2] = env->dr[2];
149 state->drs[NVMM_X64_DR_DR3] = env->dr[3];
150 state->drs[NVMM_X64_DR_DR6] = env->dr[6];
151 state->drs[NVMM_X64_DR_DR7] = env->dr[7];
152
153 /* FPU. */
154 state->fpu.fx_cw = env->fpuc;
155 state->fpu.fx_sw = (env->fpus & ~0x3800) | ((env->fpstt & 0x7) << 11);
156 state->fpu.fx_tw = 0;
157 for (i = 0; i < 8; i++) {
158 state->fpu.fx_tw |= (!env->fptags[i]) << i;
159 }
160 state->fpu.fx_opcode = env->fpop;
161 state->fpu.fx_ip.fa_64 = env->fpip;
162 state->fpu.fx_dp.fa_64 = env->fpdp;
163 state->fpu.fx_mxcsr = env->mxcsr;
164 state->fpu.fx_mxcsr_mask = 0x0000FFFF;
165 assert(sizeof(state->fpu.fx_87_ac) == sizeof(env->fpregs));
166 memcpy(state->fpu.fx_87_ac, env->fpregs, sizeof(env->fpregs));
167 for (i = 0; i < CPU_NB_REGS; i++) {
168 memcpy(&state->fpu.fx_xmm[i].xmm_bytes[0],
169 &env->xmm_regs[i].ZMM_Q(0), 8);
170 memcpy(&state->fpu.fx_xmm[i].xmm_bytes[8],
171 &env->xmm_regs[i].ZMM_Q(1), 8);
172 }
173
174 /* MSRs. */
175 state->msrs[NVMM_X64_MSR_EFER] = env->efer;
176 state->msrs[NVMM_X64_MSR_STAR] = env->star;
177 #ifdef TARGET_X86_64
178 state->msrs[NVMM_X64_MSR_LSTAR] = env->lstar;
179 state->msrs[NVMM_X64_MSR_CSTAR] = env->cstar;
180 state->msrs[NVMM_X64_MSR_SFMASK] = env->fmask;
181 state->msrs[NVMM_X64_MSR_KERNELGSBASE] = env->kernelgsbase;
182 #endif
183 state->msrs[NVMM_X64_MSR_SYSENTER_CS] = env->sysenter_cs;
184 state->msrs[NVMM_X64_MSR_SYSENTER_ESP] = env->sysenter_esp;
185 state->msrs[NVMM_X64_MSR_SYSENTER_EIP] = env->sysenter_eip;
186 state->msrs[NVMM_X64_MSR_PAT] = env->pat;
187 state->msrs[NVMM_X64_MSR_TSC] = env->tsc;
188
189 bitmap =
190 NVMM_X64_STATE_SEGS |
191 NVMM_X64_STATE_GPRS |
192 NVMM_X64_STATE_CRS |
193 NVMM_X64_STATE_DRS |
194 NVMM_X64_STATE_MSRS |
195 NVMM_X64_STATE_FPU;
196
197 ret = nvmm_vcpu_setstate(mach, vcpu, bitmap);
198 if (ret == -1) {
199 error_report("NVMM: Failed to set virtual processor context,"
200 " error=%d", errno);
201 }
202 }
203
204 static void
205 nvmm_get_segment(SegmentCache *qseg, const struct nvmm_x64_state_seg *nseg)
206 {
207 qseg->selector = nseg->selector;
208 qseg->limit = nseg->limit;
209 qseg->base = nseg->base;
210
211 qseg->flags =
212 __SHIFTIN((uint32_t)nseg->attrib.type, DESC_TYPE_MASK) |
213 __SHIFTIN((uint32_t)nseg->attrib.s, DESC_S_MASK) |
214 __SHIFTIN((uint32_t)nseg->attrib.dpl, DESC_DPL_MASK) |
215 __SHIFTIN((uint32_t)nseg->attrib.p, DESC_P_MASK) |
216 __SHIFTIN((uint32_t)nseg->attrib.avl, DESC_AVL_MASK) |
217 __SHIFTIN((uint32_t)nseg->attrib.l, DESC_L_MASK) |
218 __SHIFTIN((uint32_t)nseg->attrib.def, DESC_B_MASK) |
219 __SHIFTIN((uint32_t)nseg->attrib.g, DESC_G_MASK);
220 }
221
222 static void
223 nvmm_get_registers(CPUState *cpu)
224 {
225 CPUX86State *env = cpu->env_ptr;
226 struct nvmm_machine *mach = get_nvmm_mach();
227 struct qemu_vcpu *qcpu = get_qemu_vcpu(cpu);
228 struct nvmm_vcpu *vcpu = &qcpu->vcpu;
229 X86CPU *x86_cpu = X86_CPU(cpu);
230 struct nvmm_x64_state *state = vcpu->state;
231 uint64_t bitmap, tpr;
232 size_t i;
233 int ret;
234
235 assert(cpu_is_stopped(cpu) || qemu_cpu_is_self(cpu));
236
237 bitmap =
238 NVMM_X64_STATE_SEGS |
239 NVMM_X64_STATE_GPRS |
240 NVMM_X64_STATE_CRS |
241 NVMM_X64_STATE_DRS |
242 NVMM_X64_STATE_MSRS |
243 NVMM_X64_STATE_FPU;
244
245 ret = nvmm_vcpu_getstate(mach, vcpu, bitmap);
246 if (ret == -1) {
247 error_report("NVMM: Failed to get virtual processor context,"
248 " error=%d", errno);
249 }
250
251 /* GPRs. */
252 env->regs[R_EAX] = state->gprs[NVMM_X64_GPR_RAX];
253 env->regs[R_ECX] = state->gprs[NVMM_X64_GPR_RCX];
254 env->regs[R_EDX] = state->gprs[NVMM_X64_GPR_RDX];
255 env->regs[R_EBX] = state->gprs[NVMM_X64_GPR_RBX];
256 env->regs[R_ESP] = state->gprs[NVMM_X64_GPR_RSP];
257 env->regs[R_EBP] = state->gprs[NVMM_X64_GPR_RBP];
258 env->regs[R_ESI] = state->gprs[NVMM_X64_GPR_RSI];
259 env->regs[R_EDI] = state->gprs[NVMM_X64_GPR_RDI];
260 #ifdef TARGET_X86_64
261 env->regs[R_R8] = state->gprs[NVMM_X64_GPR_R8];
262 env->regs[R_R9] = state->gprs[NVMM_X64_GPR_R9];
263 env->regs[R_R10] = state->gprs[NVMM_X64_GPR_R10];
264 env->regs[R_R11] = state->gprs[NVMM_X64_GPR_R11];
265 env->regs[R_R12] = state->gprs[NVMM_X64_GPR_R12];
266 env->regs[R_R13] = state->gprs[NVMM_X64_GPR_R13];
267 env->regs[R_R14] = state->gprs[NVMM_X64_GPR_R14];
268 env->regs[R_R15] = state->gprs[NVMM_X64_GPR_R15];
269 #endif
270
271 /* RIP and RFLAGS. */
272 env->eip = state->gprs[NVMM_X64_GPR_RIP];
273 env->eflags = state->gprs[NVMM_X64_GPR_RFLAGS];
274
275 /* Segments. */
276 nvmm_get_segment(&env->segs[R_ES], &state->segs[NVMM_X64_SEG_ES]);
277 nvmm_get_segment(&env->segs[R_CS], &state->segs[NVMM_X64_SEG_CS]);
278 nvmm_get_segment(&env->segs[R_SS], &state->segs[NVMM_X64_SEG_SS]);
279 nvmm_get_segment(&env->segs[R_DS], &state->segs[NVMM_X64_SEG_DS]);
280 nvmm_get_segment(&env->segs[R_FS], &state->segs[NVMM_X64_SEG_FS]);
281 nvmm_get_segment(&env->segs[R_GS], &state->segs[NVMM_X64_SEG_GS]);
282
283 /* Special segments. */
284 nvmm_get_segment(&env->gdt, &state->segs[NVMM_X64_SEG_GDT]);
285 nvmm_get_segment(&env->ldt, &state->segs[NVMM_X64_SEG_LDT]);
286 nvmm_get_segment(&env->tr, &state->segs[NVMM_X64_SEG_TR]);
287 nvmm_get_segment(&env->idt, &state->segs[NVMM_X64_SEG_IDT]);
288
289 /* Control registers. */
290 env->cr[0] = state->crs[NVMM_X64_CR_CR0];
291 env->cr[2] = state->crs[NVMM_X64_CR_CR2];
292 env->cr[3] = state->crs[NVMM_X64_CR_CR3];
293 env->cr[4] = state->crs[NVMM_X64_CR_CR4];
294 tpr = state->crs[NVMM_X64_CR_CR8];
295 if (tpr != qcpu->tpr) {
296 qcpu->tpr = tpr;
297 cpu_set_apic_tpr(x86_cpu->apic_state, tpr);
298 }
299 env->xcr0 = state->crs[NVMM_X64_CR_XCR0];
300
301 /* Debug registers. */
302 env->dr[0] = state->drs[NVMM_X64_DR_DR0];
303 env->dr[1] = state->drs[NVMM_X64_DR_DR1];
304 env->dr[2] = state->drs[NVMM_X64_DR_DR2];
305 env->dr[3] = state->drs[NVMM_X64_DR_DR3];
306 env->dr[6] = state->drs[NVMM_X64_DR_DR6];
307 env->dr[7] = state->drs[NVMM_X64_DR_DR7];
308
309 /* FPU. */
310 env->fpuc = state->fpu.fx_cw;
311 env->fpstt = (state->fpu.fx_sw >> 11) & 0x7;
312 env->fpus = state->fpu.fx_sw & ~0x3800;
313 for (i = 0; i < 8; i++) {
314 env->fptags[i] = !((state->fpu.fx_tw >> i) & 1);
315 }
316 env->fpop = state->fpu.fx_opcode;
317 env->fpip = state->fpu.fx_ip.fa_64;
318 env->fpdp = state->fpu.fx_dp.fa_64;
319 env->mxcsr = state->fpu.fx_mxcsr;
320 assert(sizeof(state->fpu.fx_87_ac) == sizeof(env->fpregs));
321 memcpy(env->fpregs, state->fpu.fx_87_ac, sizeof(env->fpregs));
322 for (i = 0; i < CPU_NB_REGS; i++) {
323 memcpy(&env->xmm_regs[i].ZMM_Q(0),
324 &state->fpu.fx_xmm[i].xmm_bytes[0], 8);
325 memcpy(&env->xmm_regs[i].ZMM_Q(1),
326 &state->fpu.fx_xmm[i].xmm_bytes[8], 8);
327 }
328
329 /* MSRs. */
330 env->efer = state->msrs[NVMM_X64_MSR_EFER];
331 env->star = state->msrs[NVMM_X64_MSR_STAR];
332 #ifdef TARGET_X86_64
333 env->lstar = state->msrs[NVMM_X64_MSR_LSTAR];
334 env->cstar = state->msrs[NVMM_X64_MSR_CSTAR];
335 env->fmask = state->msrs[NVMM_X64_MSR_SFMASK];
336 env->kernelgsbase = state->msrs[NVMM_X64_MSR_KERNELGSBASE];
337 #endif
338 env->sysenter_cs = state->msrs[NVMM_X64_MSR_SYSENTER_CS];
339 env->sysenter_esp = state->msrs[NVMM_X64_MSR_SYSENTER_ESP];
340 env->sysenter_eip = state->msrs[NVMM_X64_MSR_SYSENTER_EIP];
341 env->pat = state->msrs[NVMM_X64_MSR_PAT];
342 env->tsc = state->msrs[NVMM_X64_MSR_TSC];
343
344 x86_update_hflags(env);
345 }
346
347 static bool
348 nvmm_can_take_int(CPUState *cpu)
349 {
350 CPUX86State *env = cpu->env_ptr;
351 struct qemu_vcpu *qcpu = get_qemu_vcpu(cpu);
352 struct nvmm_vcpu *vcpu = &qcpu->vcpu;
353 struct nvmm_machine *mach = get_nvmm_mach();
354
355 if (qcpu->int_window_exit) {
356 return false;
357 }
358
359 if (qcpu->int_shadow || !(env->eflags & IF_MASK)) {
360 struct nvmm_x64_state *state = vcpu->state;
361
362 /* Exit on interrupt window. */
363 nvmm_vcpu_getstate(mach, vcpu, NVMM_X64_STATE_INTR);
364 state->intr.int_window_exiting = 1;
365 nvmm_vcpu_setstate(mach, vcpu, NVMM_X64_STATE_INTR);
366
367 return false;
368 }
369
370 return true;
371 }
372
373 static bool
374 nvmm_can_take_nmi(CPUState *cpu)
375 {
376 struct qemu_vcpu *qcpu = get_qemu_vcpu(cpu);
377
378 /*
379 * Contrary to INTs, NMIs always schedule an exit when they are
380 * completed. Therefore, if window-exiting is enabled, it means
381 * NMIs are blocked.
382 */
383 if (qcpu->nmi_window_exit) {
384 return false;
385 }
386
387 return true;
388 }
389
390 /*
391 * Called before the VCPU is run. We inject events generated by the I/O
392 * thread, and synchronize the guest TPR.
393 */
394 static void
395 nvmm_vcpu_pre_run(CPUState *cpu)
396 {
397 CPUX86State *env = cpu->env_ptr;
398 struct nvmm_machine *mach = get_nvmm_mach();
399 struct qemu_vcpu *qcpu = get_qemu_vcpu(cpu);
400 struct nvmm_vcpu *vcpu = &qcpu->vcpu;
401 X86CPU *x86_cpu = X86_CPU(cpu);
402 struct nvmm_x64_state *state = vcpu->state;
403 struct nvmm_vcpu_event *event = vcpu->event;
404 bool has_event = false;
405 bool sync_tpr = false;
406 uint8_t tpr;
407 int ret;
408
409 qemu_mutex_lock_iothread();
410
411 tpr = cpu_get_apic_tpr(x86_cpu->apic_state);
412 if (tpr != qcpu->tpr) {
413 qcpu->tpr = tpr;
414 sync_tpr = true;
415 }
416
417 /*
418 * Force the VCPU out of its inner loop to process any INIT requests
419 * or commit pending TPR access.
420 */
421 if (cpu->interrupt_request & (CPU_INTERRUPT_INIT | CPU_INTERRUPT_TPR)) {
422 cpu->exit_request = 1;
423 }
424
425 if (!has_event && (cpu->interrupt_request & CPU_INTERRUPT_NMI)) {
426 if (nvmm_can_take_nmi(cpu)) {
427 cpu->interrupt_request &= ~CPU_INTERRUPT_NMI;
428 event->type = NVMM_VCPU_EVENT_INTR;
429 event->vector = 2;
430 has_event = true;
431 }
432 }
433
434 if (!has_event && (cpu->interrupt_request & CPU_INTERRUPT_HARD)) {
435 if (nvmm_can_take_int(cpu)) {
436 cpu->interrupt_request &= ~CPU_INTERRUPT_HARD;
437 event->type = NVMM_VCPU_EVENT_INTR;
438 event->vector = cpu_get_pic_interrupt(env);
439 has_event = true;
440 }
441 }
442
443 /* Don't want SMIs. */
444 if (cpu->interrupt_request & CPU_INTERRUPT_SMI) {
445 cpu->interrupt_request &= ~CPU_INTERRUPT_SMI;
446 }
447
448 if (sync_tpr) {
449 ret = nvmm_vcpu_getstate(mach, vcpu, NVMM_X64_STATE_CRS);
450 if (ret == -1) {
451 error_report("NVMM: Failed to get CPU state,"
452 " error=%d", errno);
453 }
454
455 state->crs[NVMM_X64_CR_CR8] = qcpu->tpr;
456
457 ret = nvmm_vcpu_setstate(mach, vcpu, NVMM_X64_STATE_CRS);
458 if (ret == -1) {
459 error_report("NVMM: Failed to set CPU state,"
460 " error=%d", errno);
461 }
462 }
463
464 if (has_event) {
465 ret = nvmm_vcpu_inject(mach, vcpu);
466 if (ret == -1) {
467 error_report("NVMM: Failed to inject event,"
468 " error=%d", errno);
469 }
470 }
471
472 qemu_mutex_unlock_iothread();
473 }
474
475 /*
476 * Called after the VCPU ran. We synchronize the host view of the TPR and
477 * RFLAGS.
478 */
479 static void
480 nvmm_vcpu_post_run(CPUState *cpu, struct nvmm_vcpu_exit *exit)
481 {
482 struct qemu_vcpu *qcpu = get_qemu_vcpu(cpu);
483 CPUX86State *env = cpu->env_ptr;
484 X86CPU *x86_cpu = X86_CPU(cpu);
485 uint64_t tpr;
486
487 env->eflags = exit->exitstate.rflags;
488 qcpu->int_shadow = exit->exitstate.int_shadow;
489 qcpu->int_window_exit = exit->exitstate.int_window_exiting;
490 qcpu->nmi_window_exit = exit->exitstate.nmi_window_exiting;
491
492 tpr = exit->exitstate.cr8;
493 if (qcpu->tpr != tpr) {
494 qcpu->tpr = tpr;
495 qemu_mutex_lock_iothread();
496 cpu_set_apic_tpr(x86_cpu->apic_state, qcpu->tpr);
497 qemu_mutex_unlock_iothread();
498 }
499 }
500
501 /* -------------------------------------------------------------------------- */
502
503 static void
504 nvmm_io_callback(struct nvmm_io *io)
505 {
506 MemTxAttrs attrs = { 0 };
507 int ret;
508
509 ret = address_space_rw(&address_space_io, io->port, attrs, io->data,
510 io->size, !io->in);
511 if (ret != MEMTX_OK) {
512 error_report("NVMM: I/O Transaction Failed "
513 "[%s, port=%u, size=%zu]", (io->in ? "in" : "out"),
514 io->port, io->size);
515 }
516
517 /* Needed, otherwise infinite loop. */
518 current_cpu->vcpu_dirty = false;
519 }
520
521 static void
522 nvmm_mem_callback(struct nvmm_mem *mem)
523 {
524 cpu_physical_memory_rw(mem->gpa, mem->data, mem->size, mem->write);
525
526 /* Needed, otherwise infinite loop. */
527 current_cpu->vcpu_dirty = false;
528 }
529
530 static struct nvmm_assist_callbacks nvmm_callbacks = {
531 .io = nvmm_io_callback,
532 .mem = nvmm_mem_callback
533 };
534
535 /* -------------------------------------------------------------------------- */
536
537 static int
538 nvmm_handle_mem(struct nvmm_machine *mach, struct nvmm_vcpu *vcpu)
539 {
540 int ret;
541
542 ret = nvmm_assist_mem(mach, vcpu);
543 if (ret == -1) {
544 error_report("NVMM: Mem Assist Failed [gpa=%p]",
545 (void *)vcpu->exit->u.mem.gpa);
546 }
547
548 return ret;
549 }
550
551 static int
552 nvmm_handle_io(struct nvmm_machine *mach, struct nvmm_vcpu *vcpu)
553 {
554 int ret;
555
556 ret = nvmm_assist_io(mach, vcpu);
557 if (ret == -1) {
558 error_report("NVMM: I/O Assist Failed [port=%d]",
559 (int)vcpu->exit->u.io.port);
560 }
561
562 return ret;
563 }
564
565 static int
566 nvmm_handle_rdmsr(struct nvmm_machine *mach, CPUState *cpu,
567 struct nvmm_vcpu_exit *exit)
568 {
569 struct qemu_vcpu *qcpu = get_qemu_vcpu(cpu);
570 struct nvmm_vcpu *vcpu = &qcpu->vcpu;
571 X86CPU *x86_cpu = X86_CPU(cpu);
572 struct nvmm_x64_state *state = vcpu->state;
573 uint64_t val;
574 int ret;
575
576 switch (exit->u.rdmsr.msr) {
577 case MSR_IA32_APICBASE:
578 val = cpu_get_apic_base(x86_cpu->apic_state);
579 break;
580 case MSR_MTRRcap:
581 case MSR_MTRRdefType:
582 case MSR_MCG_CAP:
583 case MSR_MCG_STATUS:
584 val = 0;
585 break;
586 default: /* More MSRs to add? */
587 val = 0;
588 error_report("NVMM: Unexpected RDMSR 0x%x, ignored",
589 exit->u.rdmsr.msr);
590 break;
591 }
592
593 ret = nvmm_vcpu_getstate(mach, vcpu, NVMM_X64_STATE_GPRS);
594 if (ret == -1) {
595 return -1;
596 }
597
598 state->gprs[NVMM_X64_GPR_RAX] = (val & 0xFFFFFFFF);
599 state->gprs[NVMM_X64_GPR_RDX] = (val >> 32);
600 state->gprs[NVMM_X64_GPR_RIP] = exit->u.rdmsr.npc;
601
602 ret = nvmm_vcpu_setstate(mach, vcpu, NVMM_X64_STATE_GPRS);
603 if (ret == -1) {
604 return -1;
605 }
606
607 return 0;
608 }
609
610 static int
611 nvmm_handle_wrmsr(struct nvmm_machine *mach, CPUState *cpu,
612 struct nvmm_vcpu_exit *exit)
613 {
614 struct qemu_vcpu *qcpu = get_qemu_vcpu(cpu);
615 struct nvmm_vcpu *vcpu = &qcpu->vcpu;
616 X86CPU *x86_cpu = X86_CPU(cpu);
617 struct nvmm_x64_state *state = vcpu->state;
618 uint64_t val;
619 int ret;
620
621 val = exit->u.wrmsr.val;
622
623 switch (exit->u.wrmsr.msr) {
624 case MSR_IA32_APICBASE:
625 cpu_set_apic_base(x86_cpu->apic_state, val);
626 break;
627 case MSR_MTRRdefType:
628 case MSR_MCG_STATUS:
629 break;
630 default: /* More MSRs to add? */
631 error_report("NVMM: Unexpected WRMSR 0x%x [val=0x%lx], ignored",
632 exit->u.wrmsr.msr, val);
633 break;
634 }
635
636 ret = nvmm_vcpu_getstate(mach, vcpu, NVMM_X64_STATE_GPRS);
637 if (ret == -1) {
638 return -1;
639 }
640
641 state->gprs[NVMM_X64_GPR_RIP] = exit->u.wrmsr.npc;
642
643 ret = nvmm_vcpu_setstate(mach, vcpu, NVMM_X64_STATE_GPRS);
644 if (ret == -1) {
645 return -1;
646 }
647
648 return 0;
649 }
650
651 static int
652 nvmm_handle_halted(struct nvmm_machine *mach, CPUState *cpu,
653 struct nvmm_vcpu_exit *exit)
654 {
655 CPUX86State *env = cpu->env_ptr;
656 int ret = 0;
657
658 qemu_mutex_lock_iothread();
659
660 if (!((cpu->interrupt_request & CPU_INTERRUPT_HARD) &&
661 (env->eflags & IF_MASK)) &&
662 !(cpu->interrupt_request & CPU_INTERRUPT_NMI)) {
663 cpu->exception_index = EXCP_HLT;
664 cpu->halted = true;
665 ret = 1;
666 }
667
668 qemu_mutex_unlock_iothread();
669
670 return ret;
671 }
672
673 static int
674 nvmm_inject_ud(struct nvmm_machine *mach, struct nvmm_vcpu *vcpu)
675 {
676 struct nvmm_vcpu_event *event = vcpu->event;
677
678 event->type = NVMM_VCPU_EVENT_EXCP;
679 event->vector = 6;
680 event->u.excp.error = 0;
681
682 return nvmm_vcpu_inject(mach, vcpu);
683 }
684
685 static int
686 nvmm_vcpu_loop(CPUState *cpu)
687 {
688 CPUX86State *env = cpu->env_ptr;
689 struct nvmm_machine *mach = get_nvmm_mach();
690 struct qemu_vcpu *qcpu = get_qemu_vcpu(cpu);
691 struct nvmm_vcpu *vcpu = &qcpu->vcpu;
692 X86CPU *x86_cpu = X86_CPU(cpu);
693 struct nvmm_vcpu_exit *exit = vcpu->exit;
694 int ret;
695
696 /*
697 * Some asynchronous events must be handled outside of the inner
698 * VCPU loop. They are handled here.
699 */
700 if (cpu->interrupt_request & CPU_INTERRUPT_INIT) {
701 nvmm_cpu_synchronize_state(cpu);
702 do_cpu_init(x86_cpu);
703 /* set int/nmi windows back to the reset state */
704 }
705 if (cpu->interrupt_request & CPU_INTERRUPT_POLL) {
706 cpu->interrupt_request &= ~CPU_INTERRUPT_POLL;
707 apic_poll_irq(x86_cpu->apic_state);
708 }
709 if (((cpu->interrupt_request & CPU_INTERRUPT_HARD) &&
710 (env->eflags & IF_MASK)) ||
711 (cpu->interrupt_request & CPU_INTERRUPT_NMI)) {
712 cpu->halted = false;
713 }
714 if (cpu->interrupt_request & CPU_INTERRUPT_SIPI) {
715 nvmm_cpu_synchronize_state(cpu);
716 do_cpu_sipi(x86_cpu);
717 }
718 if (cpu->interrupt_request & CPU_INTERRUPT_TPR) {
719 cpu->interrupt_request &= ~CPU_INTERRUPT_TPR;
720 nvmm_cpu_synchronize_state(cpu);
721 apic_handle_tpr_access_report(x86_cpu->apic_state, env->eip,
722 env->tpr_access_type);
723 }
724
725 if (cpu->halted) {
726 cpu->exception_index = EXCP_HLT;
727 qatomic_set(&cpu->exit_request, false);
728 return 0;
729 }
730
731 qemu_mutex_unlock_iothread();
732 cpu_exec_start(cpu);
733
734 /*
735 * Inner VCPU loop.
736 */
737 do {
738 if (cpu->vcpu_dirty) {
739 nvmm_set_registers(cpu);
740 cpu->vcpu_dirty = false;
741 }
742
743 if (qcpu->stop) {
744 cpu->exception_index = EXCP_INTERRUPT;
745 qcpu->stop = false;
746 ret = 1;
747 break;
748 }
749
750 nvmm_vcpu_pre_run(cpu);
751
752 if (qatomic_read(&cpu->exit_request)) {
753 #if NVMM_USER_VERSION >= 2
754 nvmm_vcpu_stop(vcpu);
755 #else
756 qemu_cpu_kick_self();
757 #endif
758 }
759
760 /* Read exit_request before the kernel reads the immediate exit flag */
761 smp_rmb();
762 ret = nvmm_vcpu_run(mach, vcpu);
763 if (ret == -1) {
764 error_report("NVMM: Failed to exec a virtual processor,"
765 " error=%d", errno);
766 break;
767 }
768
769 nvmm_vcpu_post_run(cpu, exit);
770
771 switch (exit->reason) {
772 case NVMM_VCPU_EXIT_NONE:
773 break;
774 #if NVMM_USER_VERSION >= 2
775 case NVMM_VCPU_EXIT_STOPPED:
776 /*
777 * The kernel cleared the immediate exit flag; cpu->exit_request
778 * must be cleared after
779 */
780 smp_wmb();
781 qcpu->stop = true;
782 break;
783 #endif
784 case NVMM_VCPU_EXIT_MEMORY:
785 ret = nvmm_handle_mem(mach, vcpu);
786 break;
787 case NVMM_VCPU_EXIT_IO:
788 ret = nvmm_handle_io(mach, vcpu);
789 break;
790 case NVMM_VCPU_EXIT_INT_READY:
791 case NVMM_VCPU_EXIT_NMI_READY:
792 case NVMM_VCPU_EXIT_TPR_CHANGED:
793 break;
794 case NVMM_VCPU_EXIT_HALTED:
795 ret = nvmm_handle_halted(mach, cpu, exit);
796 break;
797 case NVMM_VCPU_EXIT_SHUTDOWN:
798 qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET);
799 cpu->exception_index = EXCP_INTERRUPT;
800 ret = 1;
801 break;
802 case NVMM_VCPU_EXIT_RDMSR:
803 ret = nvmm_handle_rdmsr(mach, cpu, exit);
804 break;
805 case NVMM_VCPU_EXIT_WRMSR:
806 ret = nvmm_handle_wrmsr(mach, cpu, exit);
807 break;
808 case NVMM_VCPU_EXIT_MONITOR:
809 case NVMM_VCPU_EXIT_MWAIT:
810 ret = nvmm_inject_ud(mach, vcpu);
811 break;
812 default:
813 error_report("NVMM: Unexpected VM exit code 0x%lx [hw=0x%lx]",
814 exit->reason, exit->u.inv.hwcode);
815 nvmm_get_registers(cpu);
816 qemu_mutex_lock_iothread();
817 qemu_system_guest_panicked(cpu_get_crash_info(cpu));
818 qemu_mutex_unlock_iothread();
819 ret = -1;
820 break;
821 }
822 } while (ret == 0);
823
824 cpu_exec_end(cpu);
825 qemu_mutex_lock_iothread();
826
827 qatomic_set(&cpu->exit_request, false);
828
829 return ret < 0;
830 }
831
832 /* -------------------------------------------------------------------------- */
833
834 static void
835 do_nvmm_cpu_synchronize_state(CPUState *cpu, run_on_cpu_data arg)
836 {
837 nvmm_get_registers(cpu);
838 cpu->vcpu_dirty = true;
839 }
840
841 static void
842 do_nvmm_cpu_synchronize_post_reset(CPUState *cpu, run_on_cpu_data arg)
843 {
844 nvmm_set_registers(cpu);
845 cpu->vcpu_dirty = false;
846 }
847
848 static void
849 do_nvmm_cpu_synchronize_post_init(CPUState *cpu, run_on_cpu_data arg)
850 {
851 nvmm_set_registers(cpu);
852 cpu->vcpu_dirty = false;
853 }
854
855 static void
856 do_nvmm_cpu_synchronize_pre_loadvm(CPUState *cpu, run_on_cpu_data arg)
857 {
858 cpu->vcpu_dirty = true;
859 }
860
861 void nvmm_cpu_synchronize_state(CPUState *cpu)
862 {
863 if (!cpu->vcpu_dirty) {
864 run_on_cpu(cpu, do_nvmm_cpu_synchronize_state, RUN_ON_CPU_NULL);
865 }
866 }
867
868 void nvmm_cpu_synchronize_post_reset(CPUState *cpu)
869 {
870 run_on_cpu(cpu, do_nvmm_cpu_synchronize_post_reset, RUN_ON_CPU_NULL);
871 }
872
873 void nvmm_cpu_synchronize_post_init(CPUState *cpu)
874 {
875 run_on_cpu(cpu, do_nvmm_cpu_synchronize_post_init, RUN_ON_CPU_NULL);
876 }
877
878 void nvmm_cpu_synchronize_pre_loadvm(CPUState *cpu)
879 {
880 run_on_cpu(cpu, do_nvmm_cpu_synchronize_pre_loadvm, RUN_ON_CPU_NULL);
881 }
882
883 /* -------------------------------------------------------------------------- */
884
885 static Error *nvmm_migration_blocker;
886
887 /*
888 * The nvmm_vcpu_stop() mechanism breaks races between entering the VMM
889 * and another thread signaling the vCPU thread to exit.
890 */
891
892 static void
893 nvmm_ipi_signal(int sigcpu)
894 {
895 if (current_cpu) {
896 struct qemu_vcpu *qcpu = get_qemu_vcpu(current_cpu);
897 #if NVMM_USER_VERSION >= 2
898 struct nvmm_vcpu *vcpu = &qcpu->vcpu;
899 nvmm_vcpu_stop(vcpu);
900 #else
901 qcpu->stop = true;
902 #endif
903 }
904 }
905
906 static void
907 nvmm_init_cpu_signals(void)
908 {
909 struct sigaction sigact;
910 sigset_t set;
911
912 /* Install the IPI handler. */
913 memset(&sigact, 0, sizeof(sigact));
914 sigact.sa_handler = nvmm_ipi_signal;
915 sigaction(SIG_IPI, &sigact, NULL);
916
917 /* Allow IPIs on the current thread. */
918 sigprocmask(SIG_BLOCK, NULL, &set);
919 sigdelset(&set, SIG_IPI);
920 pthread_sigmask(SIG_SETMASK, &set, NULL);
921 }
922
923 int
924 nvmm_init_vcpu(CPUState *cpu)
925 {
926 struct nvmm_machine *mach = get_nvmm_mach();
927 struct nvmm_vcpu_conf_cpuid cpuid;
928 struct nvmm_vcpu_conf_tpr tpr;
929 Error *local_error = NULL;
930 struct qemu_vcpu *qcpu;
931 int ret, err;
932
933 nvmm_init_cpu_signals();
934
935 if (nvmm_migration_blocker == NULL) {
936 error_setg(&nvmm_migration_blocker,
937 "NVMM: Migration not supported");
938
939 if (migrate_add_blocker(nvmm_migration_blocker, &local_error) < 0) {
940 error_report_err(local_error);
941 error_free(nvmm_migration_blocker);
942 return -EINVAL;
943 }
944 }
945
946 qcpu = g_malloc0(sizeof(*qcpu));
947 if (qcpu == NULL) {
948 error_report("NVMM: Failed to allocate VCPU context.");
949 return -ENOMEM;
950 }
951
952 ret = nvmm_vcpu_create(mach, cpu->cpu_index, &qcpu->vcpu);
953 if (ret == -1) {
954 err = errno;
955 error_report("NVMM: Failed to create a virtual processor,"
956 " error=%d", err);
957 g_free(qcpu);
958 return -err;
959 }
960
961 memset(&cpuid, 0, sizeof(cpuid));
962 cpuid.mask = 1;
963 cpuid.leaf = 0x00000001;
964 cpuid.u.mask.set.edx = CPUID_MCE | CPUID_MCA | CPUID_MTRR;
965 ret = nvmm_vcpu_configure(mach, &qcpu->vcpu, NVMM_VCPU_CONF_CPUID,
966 &cpuid);
967 if (ret == -1) {
968 err = errno;
969 error_report("NVMM: Failed to configure a virtual processor,"
970 " error=%d", err);
971 g_free(qcpu);
972 return -err;
973 }
974
975 ret = nvmm_vcpu_configure(mach, &qcpu->vcpu, NVMM_VCPU_CONF_CALLBACKS,
976 &nvmm_callbacks);
977 if (ret == -1) {
978 err = errno;
979 error_report("NVMM: Failed to configure a virtual processor,"
980 " error=%d", err);
981 g_free(qcpu);
982 return -err;
983 }
984
985 if (qemu_mach.cap.arch.vcpu_conf_support & NVMM_CAP_ARCH_VCPU_CONF_TPR) {
986 memset(&tpr, 0, sizeof(tpr));
987 tpr.exit_changed = 1;
988 ret = nvmm_vcpu_configure(mach, &qcpu->vcpu, NVMM_VCPU_CONF_TPR, &tpr);
989 if (ret == -1) {
990 err = errno;
991 error_report("NVMM: Failed to configure a virtual processor,"
992 " error=%d", err);
993 g_free(qcpu);
994 return -err;
995 }
996 }
997
998 cpu->vcpu_dirty = true;
999 cpu->hax_vcpu = (struct hax_vcpu_state *)qcpu;
1000
1001 return 0;
1002 }
1003
1004 int
1005 nvmm_vcpu_exec(CPUState *cpu)
1006 {
1007 int ret, fatal;
1008
1009 while (1) {
1010 if (cpu->exception_index >= EXCP_INTERRUPT) {
1011 ret = cpu->exception_index;
1012 cpu->exception_index = -1;
1013 break;
1014 }
1015
1016 fatal = nvmm_vcpu_loop(cpu);
1017
1018 if (fatal) {
1019 error_report("NVMM: Failed to execute a VCPU.");
1020 abort();
1021 }
1022 }
1023
1024 return ret;
1025 }
1026
1027 void
1028 nvmm_destroy_vcpu(CPUState *cpu)
1029 {
1030 struct nvmm_machine *mach = get_nvmm_mach();
1031 struct qemu_vcpu *qcpu = get_qemu_vcpu(cpu);
1032
1033 nvmm_vcpu_destroy(mach, &qcpu->vcpu);
1034 g_free(cpu->hax_vcpu);
1035 }
1036
1037 /* -------------------------------------------------------------------------- */
1038
1039 static void
1040 nvmm_update_mapping(hwaddr start_pa, ram_addr_t size, uintptr_t hva,
1041 bool add, bool rom, const char *name)
1042 {
1043 struct nvmm_machine *mach = get_nvmm_mach();
1044 int ret, prot;
1045
1046 if (add) {
1047 prot = PROT_READ | PROT_EXEC;
1048 if (!rom) {
1049 prot |= PROT_WRITE;
1050 }
1051 ret = nvmm_gpa_map(mach, hva, start_pa, size, prot);
1052 } else {
1053 ret = nvmm_gpa_unmap(mach, hva, start_pa, size);
1054 }
1055
1056 if (ret == -1) {
1057 error_report("NVMM: Failed to %s GPA range '%s' PA:%p, "
1058 "Size:%p bytes, HostVA:%p, error=%d",
1059 (add ? "map" : "unmap"), name, (void *)(uintptr_t)start_pa,
1060 (void *)size, (void *)hva, errno);
1061 }
1062 }
1063
1064 static void
1065 nvmm_process_section(MemoryRegionSection *section, int add)
1066 {
1067 MemoryRegion *mr = section->mr;
1068 hwaddr start_pa = section->offset_within_address_space;
1069 ram_addr_t size = int128_get64(section->size);
1070 unsigned int delta;
1071 uintptr_t hva;
1072
1073 if (!memory_region_is_ram(mr)) {
1074 return;
1075 }
1076
1077 /* Adjust start_pa and size so that they are page-aligned. */
1078 delta = qemu_real_host_page_size() - (start_pa & ~qemu_real_host_page_mask());
1079 delta &= ~qemu_real_host_page_mask();
1080 if (delta > size) {
1081 return;
1082 }
1083 start_pa += delta;
1084 size -= delta;
1085 size &= qemu_real_host_page_mask();
1086 if (!size || (start_pa & ~qemu_real_host_page_mask())) {
1087 return;
1088 }
1089
1090 hva = (uintptr_t)memory_region_get_ram_ptr(mr) +
1091 section->offset_within_region + delta;
1092
1093 nvmm_update_mapping(start_pa, size, hva, add,
1094 memory_region_is_rom(mr), mr->name);
1095 }
1096
1097 static void
1098 nvmm_region_add(MemoryListener *listener, MemoryRegionSection *section)
1099 {
1100 memory_region_ref(section->mr);
1101 nvmm_process_section(section, 1);
1102 }
1103
1104 static void
1105 nvmm_region_del(MemoryListener *listener, MemoryRegionSection *section)
1106 {
1107 nvmm_process_section(section, 0);
1108 memory_region_unref(section->mr);
1109 }
1110
1111 static void
1112 nvmm_transaction_begin(MemoryListener *listener)
1113 {
1114 /* nothing */
1115 }
1116
1117 static void
1118 nvmm_transaction_commit(MemoryListener *listener)
1119 {
1120 /* nothing */
1121 }
1122
1123 static void
1124 nvmm_log_sync(MemoryListener *listener, MemoryRegionSection *section)
1125 {
1126 MemoryRegion *mr = section->mr;
1127
1128 if (!memory_region_is_ram(mr)) {
1129 return;
1130 }
1131
1132 memory_region_set_dirty(mr, 0, int128_get64(section->size));
1133 }
1134
1135 static MemoryListener nvmm_memory_listener = {
1136 .name = "nvmm",
1137 .begin = nvmm_transaction_begin,
1138 .commit = nvmm_transaction_commit,
1139 .region_add = nvmm_region_add,
1140 .region_del = nvmm_region_del,
1141 .log_sync = nvmm_log_sync,
1142 .priority = 10,
1143 };
1144
1145 static void
1146 nvmm_ram_block_added(RAMBlockNotifier *n, void *host, size_t size,
1147 size_t max_size)
1148 {
1149 struct nvmm_machine *mach = get_nvmm_mach();
1150 uintptr_t hva = (uintptr_t)host;
1151 int ret;
1152
1153 ret = nvmm_hva_map(mach, hva, max_size);
1154
1155 if (ret == -1) {
1156 error_report("NVMM: Failed to map HVA, HostVA:%p "
1157 "Size:%p bytes, error=%d",
1158 (void *)hva, (void *)size, errno);
1159 }
1160 }
1161
1162 static struct RAMBlockNotifier nvmm_ram_notifier = {
1163 .ram_block_added = nvmm_ram_block_added
1164 };
1165
1166 /* -------------------------------------------------------------------------- */
1167
1168 static int
1169 nvmm_accel_init(MachineState *ms)
1170 {
1171 int ret, err;
1172
1173 ret = nvmm_init();
1174 if (ret == -1) {
1175 err = errno;
1176 error_report("NVMM: Initialization failed, error=%d", errno);
1177 return -err;
1178 }
1179
1180 ret = nvmm_capability(&qemu_mach.cap);
1181 if (ret == -1) {
1182 err = errno;
1183 error_report("NVMM: Unable to fetch capability, error=%d", errno);
1184 return -err;
1185 }
1186 if (qemu_mach.cap.version < NVMM_KERN_VERSION) {
1187 error_report("NVMM: Unsupported version %u", qemu_mach.cap.version);
1188 return -EPROGMISMATCH;
1189 }
1190 if (qemu_mach.cap.state_size != sizeof(struct nvmm_x64_state)) {
1191 error_report("NVMM: Wrong state size %u", qemu_mach.cap.state_size);
1192 return -EPROGMISMATCH;
1193 }
1194
1195 ret = nvmm_machine_create(&qemu_mach.mach);
1196 if (ret == -1) {
1197 err = errno;
1198 error_report("NVMM: Machine creation failed, error=%d", errno);
1199 return -err;
1200 }
1201
1202 memory_listener_register(&nvmm_memory_listener, &address_space_memory);
1203 ram_block_notifier_add(&nvmm_ram_notifier);
1204
1205 printf("NetBSD Virtual Machine Monitor accelerator is operational\n");
1206 return 0;
1207 }
1208
1209 int
1210 nvmm_enabled(void)
1211 {
1212 return nvmm_allowed;
1213 }
1214
1215 static void
1216 nvmm_accel_class_init(ObjectClass *oc, void *data)
1217 {
1218 AccelClass *ac = ACCEL_CLASS(oc);
1219 ac->name = "NVMM";
1220 ac->init_machine = nvmm_accel_init;
1221 ac->allowed = &nvmm_allowed;
1222 }
1223
1224 static const TypeInfo nvmm_accel_type = {
1225 .name = ACCEL_CLASS_NAME("nvmm"),
1226 .parent = TYPE_ACCEL,
1227 .class_init = nvmm_accel_class_init,
1228 };
1229
1230 static void
1231 nvmm_type_init(void)
1232 {
1233 type_register_static(&nvmm_accel_type);
1234 }
1235
1236 type_init(nvmm_type_init);
QEMU mirror