Re: [PATCH v3 2/4] dump/win_dump: add helper macros for Windows dump header access

[Marc-André Lureau]

On Fri, Mar 25, 2022 at 11:51 PM Viktor Prutyanov
<viktor.prutyanov@redhat.com> wrote:
>
> Perform read access to Windows dump header fields via helper macros.
> This is preparation for the next 32-bit guest Windows dump support.
>
> Signed-off-by: Viktor Prutyanov <viktor.prutyanov@redhat.com>

Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>


> ---
>  dump/win_dump.c | 100 +++++++++++++++++++++++++++++++-----------------
>  1 file changed, 65 insertions(+), 35 deletions(-)
>
> diff --git a/dump/win_dump.c b/dump/win_dump.c
> index 29b6e4f670..df3b432ca5 100644
> --- a/dump/win_dump.c
> +++ b/dump/win_dump.c
> @@ -24,11 +24,25 @@
>  #include "hw/misc/vmcoreinfo.h"
>  #include "win_dump.h"
>
> -static size_t write_run(WinDumpPhyMemRun64 *run, int fd, Error **errp)
> +#define WIN_DUMP_PTR_SIZE sizeof(uint64_t)
> +
> +#define _WIN_DUMP_FIELD(f) (h->f)
> +#define WIN_DUMP_FIELD(field) _WIN_DUMP_FIELD(field)
> +
> +#define _WIN_DUMP_FIELD_PTR(f) ((void *)&h->f)
> +#define WIN_DUMP_FIELD_PTR(field) _WIN_DUMP_FIELD_PTR(field)
> +
> +#define _WIN_DUMP_FIELD_SIZE(f) sizeof(h->f)
> +#define WIN_DUMP_FIELD_SIZE(field) _WIN_DUMP_FIELD_SIZE(field)
> +
> +#define WIN_DUMP_CTX_SIZE sizeof(WinContext64)
> +
> +static size_t write_run(uint64_t base_page, uint64_t page_count,
> +        int fd, Error **errp)
>  {
>      void *buf;
> -    uint64_t addr = run->BasePage << TARGET_PAGE_BITS;
> -    uint64_t size = run->PageCount << TARGET_PAGE_BITS;
> +    uint64_t addr = base_page << TARGET_PAGE_BITS;
> +    uint64_t size = page_count << TARGET_PAGE_BITS;
>      uint64_t len, l;
>      size_t total = 0;
>
> @@ -59,13 +73,14 @@ static size_t write_run(WinDumpPhyMemRun64 *run, int fd, 
> Error **errp)
>
>  static void write_runs(DumpState *s, WinDumpHeader64 *h, Error **errp)
>  {
> -    WinDumpPhyMemDesc64 *desc = &h->PhysicalMemoryBlock;
> -    WinDumpPhyMemRun64 *run = desc->Run;
> +    uint64_t BasePage, PageCount;
>      Error *local_err = NULL;
>      int i;
>
> -    for (i = 0; i < desc->NumberOfRuns; i++) {
> -        s->written_size += write_run(run + i, s->fd, &local_err);
> +    for (i = 0; i < WIN_DUMP_FIELD(PhysicalMemoryBlock.NumberOfRuns); i++) {
> +        BasePage = WIN_DUMP_FIELD(PhysicalMemoryBlock.Run[i].BasePage);
> +        PageCount = WIN_DUMP_FIELD(PhysicalMemoryBlock.Run[i].PageCount);
> +        s->written_size += write_run(BasePage, PageCount, s->fd, &local_err);
>          if (local_err) {
>              error_propagate(errp, local_err);
>              return;
> @@ -73,11 +88,24 @@ static void write_runs(DumpState *s, WinDumpHeader64 *h, 
> Error **errp)
>      }
>  }
>
> +static int cpu_read_ptr(CPUState *cpu, uint64_t addr, uint64_t *ptr)
> +{
> +    int ret;
> +    uint64_t ptr64;
> +
> +    ret = cpu_memory_rw_debug(cpu, addr, &ptr64, WIN_DUMP_PTR_SIZE, 0);
> +
> +    *ptr = ptr64;
> +
> +    return ret;
> +}
> +
>  static void patch_mm_pfn_database(WinDumpHeader64 *h, Error **errp)
>  {
>      if (cpu_memory_rw_debug(first_cpu,
> -            h->KdDebuggerDataBlock + KDBG_MM_PFN_DATABASE_OFFSET64,
> -            (uint8_t *)&h->PfnDatabase, sizeof(h->PfnDatabase), 0)) {
> +            WIN_DUMP_FIELD(KdDebuggerDataBlock) + 
> KDBG_MM_PFN_DATABASE_OFFSET64,
> +            WIN_DUMP_FIELD_PTR(PfnDatabase),
> +            WIN_DUMP_FIELD_SIZE(PfnDatabase), 0)) {
>          error_setg(errp, "win-dump: failed to read MmPfnDatabase");
>          return;
>      }
> @@ -87,16 +115,17 @@ static void patch_bugcheck_data(WinDumpHeader64 *h, 
> Error **errp)
>  {
>      uint64_t KiBugcheckData;
>
> -    if (cpu_memory_rw_debug(first_cpu,
> -            h->KdDebuggerDataBlock + KDBG_KI_BUGCHECK_DATA_OFFSET64,
> -            (uint8_t *)&KiBugcheckData, sizeof(KiBugcheckData), 0)) {
> +    if (cpu_read_ptr(first_cpu,
> +            WIN_DUMP_FIELD(KdDebuggerDataBlock) +
> +                KDBG_KI_BUGCHECK_DATA_OFFSET64,
> +            &KiBugcheckData)) {
>          error_setg(errp, "win-dump: failed to read KiBugcheckData");
>          return;
>      }
>
> -    if (cpu_memory_rw_debug(first_cpu,
> -            KiBugcheckData,
> -            h->BugcheckData, sizeof(h->BugcheckData), 0)) {
> +    if (cpu_memory_rw_debug(first_cpu, KiBugcheckData,
> +            WIN_DUMP_FIELD(BugcheckData),
> +            WIN_DUMP_FIELD_SIZE(BugcheckData), 0)) {
>          error_setg(errp, "win-dump: failed to read bugcheck data");
>          return;
>      }
> @@ -105,8 +134,8 @@ static void patch_bugcheck_data(WinDumpHeader64 *h, Error 
> **errp)
>       * If BugcheckCode wasn't saved, we consider guest OS as alive.
>       */
>
> -    if (!h->BugcheckCode) {
> -        h->BugcheckCode = LIVE_SYSTEM_DUMP;
> +    if (!WIN_DUMP_FIELD(BugcheckCode)) {
> +        *(uint32_t *)WIN_DUMP_FIELD_PTR(BugcheckCode) = LIVE_SYSTEM_DUMP;
>      }
>  }
>
> @@ -155,7 +184,7 @@ static void check_kdbg(WinDumpHeader64 *h, Error **errp)
>  {
>      const char OwnerTag[] = "KDBG";
>      char read_OwnerTag[4];
> -    uint64_t KdDebuggerDataBlock = h->KdDebuggerDataBlock;
> +    uint64_t KdDebuggerDataBlock = WIN_DUMP_FIELD(KdDebuggerDataBlock);
>      bool try_fallback = true;
>
>  try_again:
> @@ -174,7 +203,7 @@ try_again:
>               * we try to use KDBG obtained by guest driver.
>               */
>
> -            KdDebuggerDataBlock = h->BugcheckParameter1;
> +            KdDebuggerDataBlock = WIN_DUMP_FIELD(BugcheckParameter1);
>              try_fallback = false;
>              goto try_again;
>          } else {
> @@ -197,20 +226,21 @@ static void patch_and_save_context(WinDumpHeader64 *h,
>                                     struct saved_context *saved_ctx,
>                                     Error **errp)
>  {
> +    uint64_t KdDebuggerDataBlock = WIN_DUMP_FIELD(KdDebuggerDataBlock);
>      uint64_t KiProcessorBlock;
>      uint16_t OffsetPrcbContext;
>      CPUState *cpu;
>      int i = 0;
>
> -    if (cpu_memory_rw_debug(first_cpu,
> -            h->KdDebuggerDataBlock + KDBG_KI_PROCESSOR_BLOCK_OFFSET64,
> -            (uint8_t *)&KiProcessorBlock, sizeof(KiProcessorBlock), 0)) {
> +    if (cpu_read_ptr(first_cpu,
> +            KdDebuggerDataBlock + KDBG_KI_PROCESSOR_BLOCK_OFFSET64,
> +            &KiProcessorBlock)) {
>          error_setg(errp, "win-dump: failed to read KiProcessorBlock");
>          return;
>      }
>
>      if (cpu_memory_rw_debug(first_cpu,
> -            h->KdDebuggerDataBlock + KDBG_OFFSET_PRCB_CONTEXT_OFFSET64,
> +            KdDebuggerDataBlock + KDBG_OFFSET_PRCB_CONTEXT_OFFSET64,
>              (uint8_t *)&OffsetPrcbContext, sizeof(OffsetPrcbContext), 0)) {
>          error_setg(errp, "win-dump: failed to read OffsetPrcbContext");
>          return;
> @@ -223,17 +253,17 @@ static void patch_and_save_context(WinDumpHeader64 *h,
>          uint64_t Context;
>          WinContext64 ctx;
>
> -        if (cpu_memory_rw_debug(first_cpu,
> -                KiProcessorBlock + i * sizeof(uint64_t),
> -                (uint8_t *)&Prcb, sizeof(Prcb), 0)) {
> +        if (cpu_read_ptr(first_cpu,
> +                KiProcessorBlock + i * WIN_DUMP_PTR_SIZE,
> +                &Prcb)) {
>              error_setg(errp, "win-dump: failed to read"
>                               " CPU #%d PRCB location", i);
>              return;
>          }
>
> -        if (cpu_memory_rw_debug(first_cpu,
> +        if (cpu_read_ptr(first_cpu,
>                  Prcb + OffsetPrcbContext,
> -                (uint8_t *)&Context, sizeof(Context), 0)) {
> +                &Context)) {
>              error_setg(errp, "win-dump: failed to read"
>                               " CPU #%d ContextFrame location", i);
>              return;
> @@ -284,13 +314,13 @@ static void patch_and_save_context(WinDumpHeader64 *h,
>          };
>
>          if (cpu_memory_rw_debug(first_cpu, Context,
> -                (uint8_t *)&saved_ctx[i].ctx, sizeof(WinContext64), 0)) {
> +                &saved_ctx[i].ctx, WIN_DUMP_CTX_SIZE, 0)) {
>              error_setg(errp, "win-dump: failed to save CPU #%d context", i);
>              return;
>          }
>
>          if (cpu_memory_rw_debug(first_cpu, Context,
> -                (uint8_t *)&ctx, sizeof(WinContext64), 1)) {
> +                &ctx, WIN_DUMP_CTX_SIZE, 1)) {
>              error_setg(errp, "win-dump: failed to write CPU #%d context", i);
>              return;
>          }
> @@ -304,9 +334,9 @@ static void restore_context(WinDumpHeader64 *h,
>  {
>      int i;
>
> -    for (i = 0; i < h->NumberProcessors; i++) {
> +    for (i = 0; i < WIN_DUMP_FIELD(NumberProcessors); i++) {
>          if (cpu_memory_rw_debug(first_cpu, saved_ctx[i].addr,
> -                (uint8_t *)&saved_ctx[i].ctx, sizeof(WinContext64), 1)) {
> +                &saved_ctx[i].ctx, WIN_DUMP_CTX_SIZE, 1)) {
>              warn_report("win-dump: failed to restore CPU #%d context", i);
>          }
>      }
> @@ -338,7 +368,7 @@ void create_win_dump(DumpState *s, Error **errp)
>       * should be made from system context.
>       */
>
> -    first_x86_cpu->env.cr[3] = h->DirectoryTableBase;
> +    first_x86_cpu->env.cr[3] = WIN_DUMP_FIELD(DirectoryTableBase);
>
>      check_kdbg(h, &local_err);
>      if (local_err) {
> @@ -348,7 +378,7 @@ void create_win_dump(DumpState *s, Error **errp)
>
>      patch_header(h);
>
> -    saved_ctx = g_new(struct saved_context, h->NumberProcessors);
> +    saved_ctx = g_new(struct saved_context, 
> WIN_DUMP_FIELD(NumberProcessors));
>
>      /*
>       * Always patch context because there is no way
> @@ -361,7 +391,7 @@ void create_win_dump(DumpState *s, Error **errp)
>          goto out_free;
>      }
>
> -    s->total_size = h->RequiredDumpSpace;
> +    s->total_size = WIN_DUMP_FIELD(RequiredDumpSpace);
>
>      s->written_size = qemu_write_full(s->fd, h, sizeof(*h));
>      if (s->written_size != sizeof(*h)) {
> --
> 2.35.1
>