hw/acpi/piix4: move xen_enabled() logic from piix4_pm_init() to piix4_pm_realize()
[qemu/kevin.git] / dump / win_dump.c
blobfd91350fbb8e249d747a8e10fa709359db547c7a
1 /*
2 * Windows crashdump
4 * Copyright (c) 2018 Virtuozzo International GmbH
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.
9 */
11 #include "qemu/osdep.h"
12 #include "qemu/cutils.h"
13 #include "elf.h"
14 #include "exec/hwaddr.h"
15 #include "monitor/monitor.h"
16 #include "sysemu/kvm.h"
17 #include "sysemu/dump.h"
18 #include "sysemu/memory_mapping.h"
19 #include "sysemu/cpus.h"
20 #include "qapi/error.h"
21 #include "qapi/qmp/qerror.h"
22 #include "qemu/error-report.h"
23 #include "hw/misc/vmcoreinfo.h"
24 #include "win_dump.h"
26 static size_t win_dump_ptr_size(bool x64)
28 return x64 ? sizeof(uint64_t) : sizeof(uint32_t);
31 #define _WIN_DUMP_FIELD(f) (x64 ? h->x64.f : h->x32.f)
32 #define WIN_DUMP_FIELD(field) _WIN_DUMP_FIELD(field)
34 #define _WIN_DUMP_FIELD_PTR(f) (x64 ? (void *)&h->x64.f : (void *)&h->x32.f)
35 #define WIN_DUMP_FIELD_PTR(field) _WIN_DUMP_FIELD_PTR(field)
37 #define _WIN_DUMP_FIELD_SIZE(f) (x64 ? sizeof(h->x64.f) : sizeof(h->x32.f))
38 #define WIN_DUMP_FIELD_SIZE(field) _WIN_DUMP_FIELD_SIZE(field)
40 static size_t win_dump_ctx_size(bool x64)
42 return x64 ? sizeof(WinContext64) : sizeof(WinContext32);
45 static size_t write_run(uint64_t base_page, uint64_t page_count,
46 int fd, Error **errp)
48 void *buf;
49 uint64_t addr = base_page << TARGET_PAGE_BITS;
50 uint64_t size = page_count << TARGET_PAGE_BITS;
51 uint64_t len, l;
52 size_t total = 0;
54 while (size) {
55 len = size;
57 buf = cpu_physical_memory_map(addr, &len, false);
58 if (!buf) {
59 error_setg(errp, "win-dump: failed to map physical range"
60 " 0x%016" PRIx64 "-0x%016" PRIx64, addr, addr + size - 1);
61 return 0;
64 l = qemu_write_full(fd, buf, len);
65 cpu_physical_memory_unmap(buf, addr, false, len);
66 if (l != len) {
67 error_setg(errp, QERR_IO_ERROR);
68 return 0;
71 addr += l;
72 size -= l;
73 total += l;
76 return total;
79 static void write_runs(DumpState *s, WinDumpHeader *h, bool x64, Error **errp)
81 uint64_t BasePage, PageCount;
82 Error *local_err = NULL;
83 int i;
85 for (i = 0; i < WIN_DUMP_FIELD(PhysicalMemoryBlock.NumberOfRuns); i++) {
86 BasePage = WIN_DUMP_FIELD(PhysicalMemoryBlock.Run[i].BasePage);
87 PageCount = WIN_DUMP_FIELD(PhysicalMemoryBlock.Run[i].PageCount);
88 s->written_size += write_run(BasePage, PageCount, s->fd, &local_err);
89 if (local_err) {
90 error_propagate(errp, local_err);
91 return;
96 static int cpu_read_ptr(bool x64, CPUState *cpu, uint64_t addr, uint64_t *ptr)
98 int ret;
99 uint32_t ptr32;
100 uint64_t ptr64;
102 ret = cpu_memory_rw_debug(cpu, addr, x64 ? (void *)&ptr64 : (void *)&ptr32,
103 win_dump_ptr_size(x64), 0);
105 *ptr = x64 ? ptr64 : ptr32;
107 return ret;
110 static void patch_mm_pfn_database(WinDumpHeader *h, bool x64, Error **errp)
112 if (cpu_memory_rw_debug(first_cpu,
113 WIN_DUMP_FIELD(KdDebuggerDataBlock) + KDBG_MM_PFN_DATABASE_OFFSET,
114 WIN_DUMP_FIELD_PTR(PfnDatabase),
115 WIN_DUMP_FIELD_SIZE(PfnDatabase), 0)) {
116 error_setg(errp, "win-dump: failed to read MmPfnDatabase");
117 return;
121 static void patch_bugcheck_data(WinDumpHeader *h, bool x64, Error **errp)
123 uint64_t KiBugcheckData;
125 if (cpu_read_ptr(x64, first_cpu,
126 WIN_DUMP_FIELD(KdDebuggerDataBlock) + KDBG_KI_BUGCHECK_DATA_OFFSET,
127 &KiBugcheckData)) {
128 error_setg(errp, "win-dump: failed to read KiBugcheckData");
129 return;
132 if (cpu_memory_rw_debug(first_cpu, KiBugcheckData,
133 WIN_DUMP_FIELD(BugcheckData),
134 WIN_DUMP_FIELD_SIZE(BugcheckData), 0)) {
135 error_setg(errp, "win-dump: failed to read bugcheck data");
136 return;
140 * If BugcheckCode wasn't saved, we consider guest OS as alive.
143 if (!WIN_DUMP_FIELD(BugcheckCode)) {
144 *(uint32_t *)WIN_DUMP_FIELD_PTR(BugcheckCode) = LIVE_SYSTEM_DUMP;
149 * This routine tries to correct mistakes in crashdump header.
151 static void patch_header(WinDumpHeader *h, bool x64)
153 Error *local_err = NULL;
155 if (x64) {
156 h->x64.RequiredDumpSpace = sizeof(WinDumpHeader64) +
157 (h->x64.PhysicalMemoryBlock.NumberOfPages << TARGET_PAGE_BITS);
158 h->x64.PhysicalMemoryBlock.unused = 0;
159 h->x64.unused1 = 0;
160 } else {
161 h->x32.RequiredDumpSpace = sizeof(WinDumpHeader32) +
162 (h->x32.PhysicalMemoryBlock.NumberOfPages << TARGET_PAGE_BITS);
165 patch_mm_pfn_database(h, x64, &local_err);
166 if (local_err) {
167 warn_report_err(local_err);
168 local_err = NULL;
170 patch_bugcheck_data(h, x64, &local_err);
171 if (local_err) {
172 warn_report_err(local_err);
176 static bool check_header(WinDumpHeader *h, bool *x64, Error **errp)
178 const char Signature[] = "PAGE";
180 if (memcmp(h->Signature, Signature, sizeof(h->Signature))) {
181 error_setg(errp, "win-dump: invalid header, expected '%.4s',"
182 " got '%.4s'", Signature, h->Signature);
183 return false;
186 if (!memcmp(h->ValidDump, "DUMP", sizeof(h->ValidDump))) {
187 *x64 = false;
188 } else if (!memcmp(h->ValidDump, "DU64", sizeof(h->ValidDump))) {
189 *x64 = true;
190 } else {
191 error_setg(errp, "win-dump: invalid header, expected 'DUMP' or 'DU64',"
192 " got '%.4s'", h->ValidDump);
193 return false;
196 return true;
199 static void check_kdbg(WinDumpHeader *h, bool x64, Error **errp)
201 const char OwnerTag[] = "KDBG";
202 char read_OwnerTag[4];
203 uint64_t KdDebuggerDataBlock = WIN_DUMP_FIELD(KdDebuggerDataBlock);
204 bool try_fallback = true;
206 try_again:
207 if (cpu_memory_rw_debug(first_cpu,
208 KdDebuggerDataBlock + KDBG_OWNER_TAG_OFFSET,
209 (uint8_t *)&read_OwnerTag, sizeof(read_OwnerTag), 0)) {
210 error_setg(errp, "win-dump: failed to read OwnerTag");
211 return;
214 if (memcmp(read_OwnerTag, OwnerTag, sizeof(read_OwnerTag))) {
215 if (try_fallback) {
217 * If attempt to use original KDBG failed
218 * (most likely because of its encryption),
219 * we try to use KDBG obtained by guest driver.
222 KdDebuggerDataBlock = WIN_DUMP_FIELD(BugcheckParameter1);
223 try_fallback = false;
224 goto try_again;
225 } else {
226 error_setg(errp, "win-dump: invalid KDBG OwnerTag,"
227 " expected '%.4s', got '%.4s'",
228 OwnerTag, read_OwnerTag);
229 return;
233 if (x64) {
234 h->x64.KdDebuggerDataBlock = KdDebuggerDataBlock;
235 } else {
236 h->x32.KdDebuggerDataBlock = KdDebuggerDataBlock;
240 struct saved_context {
241 WinContext ctx;
242 uint64_t addr;
245 static void patch_and_save_context(WinDumpHeader *h, bool x64,
246 struct saved_context *saved_ctx,
247 Error **errp)
249 uint64_t KdDebuggerDataBlock = WIN_DUMP_FIELD(KdDebuggerDataBlock);
250 uint64_t KiProcessorBlock;
251 uint16_t OffsetPrcbContext;
252 CPUState *cpu;
253 int i = 0;
255 if (cpu_read_ptr(x64, first_cpu,
256 KdDebuggerDataBlock + KDBG_KI_PROCESSOR_BLOCK_OFFSET,
257 &KiProcessorBlock)) {
258 error_setg(errp, "win-dump: failed to read KiProcessorBlock");
259 return;
262 if (cpu_memory_rw_debug(first_cpu,
263 KdDebuggerDataBlock + KDBG_OFFSET_PRCB_CONTEXT_OFFSET,
264 (uint8_t *)&OffsetPrcbContext, sizeof(OffsetPrcbContext), 0)) {
265 error_setg(errp, "win-dump: failed to read OffsetPrcbContext");
266 return;
269 CPU_FOREACH(cpu) {
270 X86CPU *x86_cpu = X86_CPU(cpu);
271 CPUX86State *env = &x86_cpu->env;
272 uint64_t Prcb;
273 uint64_t Context;
274 WinContext ctx;
276 if (cpu_read_ptr(x64, first_cpu,
277 KiProcessorBlock + i * win_dump_ptr_size(x64),
278 &Prcb)) {
279 error_setg(errp, "win-dump: failed to read"
280 " CPU #%d PRCB location", i);
281 return;
284 if (cpu_read_ptr(x64, first_cpu,
285 Prcb + OffsetPrcbContext,
286 &Context)) {
287 error_setg(errp, "win-dump: failed to read"
288 " CPU #%d ContextFrame location", i);
289 return;
292 saved_ctx[i].addr = Context;
294 if (x64) {
295 ctx.x64 = (WinContext64){
296 .ContextFlags = WIN_CTX64_ALL,
297 .MxCsr = env->mxcsr,
299 .SegEs = env->segs[0].selector,
300 .SegCs = env->segs[1].selector,
301 .SegSs = env->segs[2].selector,
302 .SegDs = env->segs[3].selector,
303 .SegFs = env->segs[4].selector,
304 .SegGs = env->segs[5].selector,
305 .EFlags = cpu_compute_eflags(env),
307 .Dr0 = env->dr[0],
308 .Dr1 = env->dr[1],
309 .Dr2 = env->dr[2],
310 .Dr3 = env->dr[3],
311 .Dr6 = env->dr[6],
312 .Dr7 = env->dr[7],
314 .Rax = env->regs[R_EAX],
315 .Rbx = env->regs[R_EBX],
316 .Rcx = env->regs[R_ECX],
317 .Rdx = env->regs[R_EDX],
318 .Rsp = env->regs[R_ESP],
319 .Rbp = env->regs[R_EBP],
320 .Rsi = env->regs[R_ESI],
321 .Rdi = env->regs[R_EDI],
322 .R8 = env->regs[8],
323 .R9 = env->regs[9],
324 .R10 = env->regs[10],
325 .R11 = env->regs[11],
326 .R12 = env->regs[12],
327 .R13 = env->regs[13],
328 .R14 = env->regs[14],
329 .R15 = env->regs[15],
331 .Rip = env->eip,
332 .FltSave = {
333 .MxCsr = env->mxcsr,
336 } else {
337 ctx.x32 = (WinContext32){
338 .ContextFlags = WIN_CTX32_FULL | WIN_CTX_DBG,
340 .SegEs = env->segs[0].selector,
341 .SegCs = env->segs[1].selector,
342 .SegSs = env->segs[2].selector,
343 .SegDs = env->segs[3].selector,
344 .SegFs = env->segs[4].selector,
345 .SegGs = env->segs[5].selector,
346 .EFlags = cpu_compute_eflags(env),
348 .Dr0 = env->dr[0],
349 .Dr1 = env->dr[1],
350 .Dr2 = env->dr[2],
351 .Dr3 = env->dr[3],
352 .Dr6 = env->dr[6],
353 .Dr7 = env->dr[7],
355 .Eax = env->regs[R_EAX],
356 .Ebx = env->regs[R_EBX],
357 .Ecx = env->regs[R_ECX],
358 .Edx = env->regs[R_EDX],
359 .Esp = env->regs[R_ESP],
360 .Ebp = env->regs[R_EBP],
361 .Esi = env->regs[R_ESI],
362 .Edi = env->regs[R_EDI],
364 .Eip = env->eip,
368 if (cpu_memory_rw_debug(first_cpu, Context,
369 &saved_ctx[i].ctx, win_dump_ctx_size(x64), 0)) {
370 error_setg(errp, "win-dump: failed to save CPU #%d context", i);
371 return;
374 if (cpu_memory_rw_debug(first_cpu, Context,
375 &ctx, win_dump_ctx_size(x64), 1)) {
376 error_setg(errp, "win-dump: failed to write CPU #%d context", i);
377 return;
380 i++;
384 static void restore_context(WinDumpHeader *h, bool x64,
385 struct saved_context *saved_ctx)
387 int i;
389 for (i = 0; i < WIN_DUMP_FIELD(NumberProcessors); i++) {
390 if (cpu_memory_rw_debug(first_cpu, saved_ctx[i].addr,
391 &saved_ctx[i].ctx, win_dump_ctx_size(x64), 1)) {
392 warn_report("win-dump: failed to restore CPU #%d context", i);
397 void create_win_dump(DumpState *s, Error **errp)
399 WinDumpHeader *h = (void *)(s->guest_note + VMCOREINFO_ELF_NOTE_HDR_SIZE);
400 X86CPU *first_x86_cpu = X86_CPU(first_cpu);
401 uint64_t saved_cr3 = first_x86_cpu->env.cr[3];
402 struct saved_context *saved_ctx = NULL;
403 Error *local_err = NULL;
404 bool x64 = true;
405 size_t hdr_size;
407 if (s->guest_note_size != VMCOREINFO_WIN_DUMP_NOTE_SIZE32 &&
408 s->guest_note_size != VMCOREINFO_WIN_DUMP_NOTE_SIZE64) {
409 error_setg(errp, "win-dump: invalid vmcoreinfo note size");
410 return;
413 if (!check_header(h, &x64, &local_err)) {
414 error_propagate(errp, local_err);
415 return;
418 hdr_size = x64 ? sizeof(WinDumpHeader64) : sizeof(WinDumpHeader32);
421 * Further access to kernel structures by virtual addresses
422 * should be made from system context.
425 first_x86_cpu->env.cr[3] = WIN_DUMP_FIELD(DirectoryTableBase);
427 check_kdbg(h, x64, &local_err);
428 if (local_err) {
429 error_propagate(errp, local_err);
430 goto out_cr3;
433 patch_header(h, x64);
435 saved_ctx = g_new(struct saved_context, WIN_DUMP_FIELD(NumberProcessors));
438 * Always patch context because there is no way
439 * to determine if the system-saved context is valid
442 patch_and_save_context(h, x64, saved_ctx, &local_err);
443 if (local_err) {
444 error_propagate(errp, local_err);
445 goto out_free;
448 s->total_size = WIN_DUMP_FIELD(RequiredDumpSpace);
450 s->written_size = qemu_write_full(s->fd, h, hdr_size);
451 if (s->written_size != hdr_size) {
452 error_setg(errp, QERR_IO_ERROR);
453 goto out_restore;
456 write_runs(s, h, x64, &local_err);
457 if (local_err) {
458 error_propagate(errp, local_err);
459 goto out_restore;
462 out_restore:
463 restore_context(h, x64, saved_ctx);
464 out_free:
465 g_free(saved_ctx);
466 out_cr3:
467 first_x86_cpu->env.cr[3] = saved_cr3;
469 return;