xref: /aosp_15_r20/external/mesa3d/src/intel/tools/error2aub.c (revision 6104692788411f58d303aa86923a9ff6ecaded22)

/*
 * Copyright © 2018 Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 *
 */

#include <assert.h>
#include <getopt.h>
#include <inttypes.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <zlib.h>

#include "util/list.h"

#include "aub_write.h"
#include "error_decode_lib.h"
#include "intel_aub.h"

#define fail_if(cond, ...) _fail_if(cond, NULL, __VA_ARGS__)

#define fail(...) fail_if(true, __VA_ARGS__)

static int zlib_inflate(uint32_t **ptr, int len)
{
   struct z_stream_s zstream;
   void *out;
   const uint32_t out_size = 128*4096;  /* approximate obj size */

   memset(&zstream, 0, sizeof(zstream));

   zstream.next_in = (unsigned char *)*ptr;
   zstream.avail_in = 4*len;

   if (inflateInit(&zstream) != Z_OK)
      return 0;

   out = malloc(out_size);
   zstream.next_out = out;
   zstream.avail_out = out_size;

   do {
      switch (inflate(&zstream, Z_SYNC_FLUSH)) {
      case Z_STREAM_END:
         goto end;
      case Z_OK:
         break;
      default:
         inflateEnd(&zstream);
         return 0;
      }

      if (zstream.avail_out)
         break;

      out = realloc(out, 2*zstream.total_out);
      if (out == NULL) {
         inflateEnd(&zstream);
         return 0;
      }

      zstream.next_out = (unsigned char *)out + zstream.total_out;
      zstream.avail_out = zstream.total_out;
   } while (1);
 end:
   inflateEnd(&zstream);
   free(*ptr);
   *ptr = out;
   return zstream.total_out / 4;
}

static int ascii85_decode(const char *in, uint32_t **out, bool inflate)
{
   int len = 0, size = 1024;

   *out = realloc(*out, sizeof(uint32_t)*size);
   if (*out == NULL)
      return 0;

   while (*in >= '!' && *in <= 'z') {
      uint32_t v = 0;

      if (len == size) {
         size *= 2;
         *out = realloc(*out, sizeof(uint32_t)*size);
         if (*out == NULL)
            return 0;
      }

      in = ascii85_decode_char(in, &v);
      (*out)[len++] = v;
   }

   if (!inflate)
      return len;

   return zlib_inflate(out, len);
}

static void
print_help(const char *progname, FILE *file)
{
   fprintf(file,
           "Usage: %s [OPTION]... [FILE]\n"
           "Convert an Intel GPU i915 error state to an aub file.\n"
           "  -h, --help          display this help and exit\n"
           "  -o, --output=FILE   the output aub file (default FILE.aub)\n",
           progname);
}

struct bo {
   enum address_space {
      PPGTT,
      GGTT,
   } gtt;
   enum bo_type {
      BO_TYPE_UNKNOWN = 0,
      BO_TYPE_BATCH,
      BO_TYPE_USER,
      BO_TYPE_CONTEXT,
      BO_TYPE_RINGBUFFER,
      BO_TYPE_STATUS,
      BO_TYPE_CONTEXT_WA,
   } type;
   const char *name;
   uint64_t addr;
   uint8_t *data;
   uint64_t size;

   enum intel_engine_class engine_class;
   int engine_instance;

   struct list_head link;
};

static struct bo *
find_or_create(struct list_head *bo_list, uint64_t addr,
               enum address_space gtt,
               enum intel_engine_class engine_class,
               int engine_instance)
{
   list_for_each_entry(struct bo, bo_entry, bo_list, link) {
      if (bo_entry->addr == addr &&
          bo_entry->gtt == gtt &&
          bo_entry->engine_class == engine_class &&
          bo_entry->engine_instance == engine_instance)
         return bo_entry;
   }

   struct bo *new_bo = calloc(1, sizeof(*new_bo));
   new_bo->addr = addr;
   new_bo->gtt = gtt;
   new_bo->engine_class = engine_class;
   new_bo->engine_instance = engine_instance;
   list_addtail(&new_bo->link, bo_list);

   return new_bo;
}

static void
engine_from_name(const char *engine_name,
                 enum intel_engine_class *engine_class,
                 int *engine_instance)
{
   const struct {
      const char *match;
      enum intel_engine_class engine_class;
      bool parse_instance;
   } rings[] = {
      { "rcs", INTEL_ENGINE_CLASS_RENDER, true },
      { "vcs", INTEL_ENGINE_CLASS_VIDEO, true },
      { "vecs", INTEL_ENGINE_CLASS_VIDEO_ENHANCE, true },
      { "bcs", INTEL_ENGINE_CLASS_COPY, true },
      { "global", INTEL_ENGINE_CLASS_INVALID, false },
      { "render command stream", INTEL_ENGINE_CLASS_RENDER, false },
      { "blt command stream", INTEL_ENGINE_CLASS_COPY, false },
      { "bsd command stream", INTEL_ENGINE_CLASS_VIDEO, false },
      { "vebox command stream", INTEL_ENGINE_CLASS_VIDEO_ENHANCE, false },
      { NULL, INTEL_ENGINE_CLASS_INVALID },
   }, *r;

   for (r = rings; r->match; r++) {
      if (strncasecmp(engine_name, r->match, strlen(r->match)) == 0) {
         *engine_class = r->engine_class;
         if (r->parse_instance)
            *engine_instance = strtol(engine_name + strlen(r->match), NULL, 10);
         else
            *engine_instance = 0;
         return;
      }
   }

   fail("Unknown engine %s\n", engine_name);
}

int
main(int argc, char *argv[])
{
   int i, c;
   bool help = false, verbose = false;
   char *out_filename = NULL, *in_filename = NULL;
   const struct option aubinator_opts[] = {
      { "help",       no_argument,       NULL,     'h' },
      { "output",     required_argument, NULL,     'o' },
      { "verbose",    no_argument,       NULL,     'v' },
      { NULL,         0,                 NULL,     0 }
   };

   i = 0;
   while ((c = getopt_long(argc, argv, "ho:v", aubinator_opts, &i)) != -1) {
      switch (c) {
      case 'h':
         help = true;
         break;
      case 'o':
         out_filename = strdup(optarg);
         break;
      case 'v':
         verbose = true;
         break;
      default:
         break;
      }
   }

   if (optind < argc)
      in_filename = argv[optind++];

   if (help || argc == 1 || !in_filename) {
      print_help(argv[0], stderr);
      return in_filename ? EXIT_SUCCESS : EXIT_FAILURE;
   }

   if (out_filename == NULL) {
      int out_filename_size = strlen(in_filename) + 5;
      out_filename = malloc(out_filename_size);
      snprintf(out_filename, out_filename_size, "%s.aub", in_filename);
   }

   FILE *err_file = fopen(in_filename, "r");
   fail_if(!err_file, "Failed to open error file \"%s\": %m\n", in_filename);

   FILE *aub_file = fopen(out_filename, "w");
   fail_if(!aub_file, "Failed to open aub file \"%s\": %m\n", in_filename);

   struct aub_file aub = {};

   enum intel_engine_class active_engine_class = INTEL_ENGINE_CLASS_INVALID;
   int active_engine_instance = -1;

   enum address_space active_gtt = PPGTT;
   enum address_space default_gtt = PPGTT;

   struct {
      struct {
         uint32_t ring_buffer_head;
         uint32_t ring_buffer_tail;
      } instances[3];
   } engines[INTEL_ENGINE_CLASS_INVALID + 1];
   memset(engines, 0, sizeof(engines));

   int num_ring_bos = 0;

   struct list_head bo_list;
   list_inithead(&bo_list);

   struct bo *last_bo = NULL;

   char *line = NULL;
   size_t line_size;
   while (getline(&line, &line_size, err_file) > 0) {
      const char *pci_id_start = strstr(line, "PCI ID");
      if (pci_id_start) {
         int pci_id;
         int matched = sscanf(line, "PCI ID: 0x%04x\n", &pci_id);
         fail_if(!matched, "Invalid error state file!\n");

         aub_file_init(&aub, aub_file,
                       NULL, pci_id, "error_state");
         if (verbose)
            aub.verbose_log_file = stdout;
         default_gtt = active_gtt = aub_use_execlists(&aub) ? PPGTT : GGTT;
         continue;
      }

      if (strstr(line, " command stream:")) {
         engine_from_name(line, &active_engine_class, &active_engine_instance);
         continue;
      }

      if (sscanf(line, "  ring->head: 0x%x\n",
                 &engines[
                    active_engine_class].instances[
                       active_engine_instance].ring_buffer_head) == 1) {
         continue;
      }

      if (sscanf(line, "  ring->tail: 0x%x\n",
                 &engines[
                    active_engine_class].instances[
                       active_engine_instance].ring_buffer_tail) == 1) {
         continue;
      }

      const char *active_start = "Active (";
      if (strncmp(line, active_start, strlen(active_start)) == 0) {
         char *ring = line + strlen(active_start);

         engine_from_name(ring, &active_engine_class, &active_engine_instance);
         active_gtt = default_gtt;

         char *count = strchr(ring, '[');
         fail_if(!count || sscanf(count, "[%d]:", &num_ring_bos) < 1,
                 "Failed to parse BO table header\n");
         continue;
      }

      const char *global_start = "Pinned (global) [";
      if (strncmp(line, global_start, strlen(global_start)) == 0) {
         active_engine_class = INTEL_ENGINE_CLASS_INVALID;
         active_engine_instance = -1;
         active_gtt = GGTT;
         continue;
      }

      if (num_ring_bos > 0) {
         unsigned hi, lo, size;
         if (sscanf(line, " %x_%x %d", &hi, &lo, &size) == 3) {
            struct bo *bo_entry = find_or_create(&bo_list, ((uint64_t)hi) << 32 | lo,
                                                 active_gtt,
                                                 active_engine_class,
                                                 active_engine_instance);
            bo_entry->size = size;
            num_ring_bos--;
         } else {
            fail("Not enough BO entries in the active table\n");
         }
         continue;
      }

      if (line[0] == ':' || line[0] == '~') {
         if (!last_bo || last_bo->type == BO_TYPE_UNKNOWN)
            continue;

         int count = ascii85_decode(line+1, (uint32_t **) &last_bo->data, line[0] == ':');
         fail_if(count == 0, "ASCII85 decode failed.\n");
         last_bo->size = count * 4;
         continue;
      }

      char *dashes = strstr(line, " --- ");
      if (dashes) {
         dashes += 5;

         engine_from_name(line, &active_engine_class, &active_engine_instance);

         uint32_t hi, lo;
         char *bo_address_str = strchr(dashes, '=');
         if (!bo_address_str || sscanf(bo_address_str, "= 0x%08x %08x\n", &hi, &lo) != 2)
            continue;

         const struct {
            const char *match;
            enum bo_type type;
            enum address_space gtt;
         } bo_types[] = {
            { "gtt_offset", BO_TYPE_BATCH,      default_gtt },
            { "batch",      BO_TYPE_BATCH,      default_gtt },
            { "user",       BO_TYPE_USER,       default_gtt },
            { "HW context", BO_TYPE_CONTEXT,    GGTT },
            { "ringbuffer", BO_TYPE_RINGBUFFER, GGTT },
            { "HW Status",  BO_TYPE_STATUS,     GGTT },
            { "WA context", BO_TYPE_CONTEXT_WA, GGTT },
            { "unknown",    BO_TYPE_UNKNOWN,    GGTT },
         }, *b;

         for (b = bo_types; b->type != BO_TYPE_UNKNOWN; b++) {
            if (strncasecmp(dashes, b->match, strlen(b->match)) == 0)
               break;
         }

         last_bo = find_or_create(&bo_list, ((uint64_t) hi) << 32 | lo,
                                  b->gtt,
                                  active_engine_class, active_engine_instance);

         /* The batch buffer will appear twice as gtt_offset and user. Only
          * keep the batch type.
          */
         if (last_bo->type == BO_TYPE_UNKNOWN) {
            last_bo->type = b->type;
            last_bo->name = b->match;
         }

         continue;
      }
   }

   if (verbose) {
      fprintf(stdout, "BOs found:\n");
      list_for_each_entry(struct bo, bo_entry, &bo_list, link) {
         fprintf(stdout, "\t type=%i addr=0x%016" PRIx64 " size=%" PRIu64 "\n",
                 bo_entry->type, bo_entry->addr, bo_entry->size);
      }
   }

   /* Find the batch that trigger the hang */
   struct bo *batch_bo = NULL;
   list_for_each_entry(struct bo, bo_entry, &bo_list, link) {
      if (bo_entry->type == BO_TYPE_BATCH) {
         batch_bo = bo_entry;
         break;
      }
   }
   fail_if(!batch_bo, "Failed to find batch buffer.\n");

   /* Add all the BOs to the aub file */
   struct bo *hwsp_bo = NULL;
   list_for_each_entry(struct bo, bo_entry, &bo_list, link) {
      switch (bo_entry->type) {
      case BO_TYPE_BATCH:
         if (bo_entry->gtt == PPGTT) {
            aub_map_ppgtt(&aub, bo_entry->addr, bo_entry->size);
            aub_write_trace_block(&aub, AUB_TRACE_TYPE_BATCH,
                                  bo_entry->data, bo_entry->size, bo_entry->addr);
         } else
            aub_write_ggtt(&aub, bo_entry->addr, bo_entry->size, bo_entry->data);
         break;
      case BO_TYPE_USER:
         if (bo_entry->gtt == PPGTT) {
            aub_map_ppgtt(&aub, bo_entry->addr, bo_entry->size);
            aub_write_trace_block(&aub, AUB_TRACE_TYPE_NOTYPE,
                                  bo_entry->data, bo_entry->size, bo_entry->addr);
         } else
            aub_write_ggtt(&aub, bo_entry->addr, bo_entry->size, bo_entry->data);
         break;
      case BO_TYPE_CONTEXT:
         if (bo_entry->engine_class == batch_bo->engine_class &&
             bo_entry->engine_instance == batch_bo->engine_instance &&
             aub_use_execlists(&aub)) {
            hwsp_bo = bo_entry;

            uint32_t *context = (uint32_t *) (bo_entry->data + 4096 /* GuC */ + 4096 /* HWSP */);

            if (context[1] == 0) {
               fprintf(stderr,
                       "Invalid context image data.\n"
                       "This is likely a kernel issue : https://bugs.freedesktop.org/show_bug.cgi?id=107691\n");
            }

            /* Update the ring buffer at the last known location. */
            context[5] = engines[bo_entry->engine_class].instances[bo_entry->engine_instance].ring_buffer_head;
            context[7] = engines[bo_entry->engine_class].instances[bo_entry->engine_instance].ring_buffer_tail;
            fprintf(stdout, "engine start=0x%x head/tail=0x%x/0x%x\n",
                    context[9], context[5], context[7]);

            /* The error state doesn't provide a dump of the page tables, so
             * we have to provide our own, that's easy enough.
             */
            context[49] = aub.pml4.phys_addr >> 32;
            context[51] = aub.pml4.phys_addr & 0xffffffff;

            fprintf(stdout, "context dump:\n");
            for (int i = 0; i < 60; i++) {
               if (i % 4 == 0)
                  fprintf(stdout, "\n 0x%08" PRIx64 ": ", bo_entry->addr + 8192 + i * 4);
               fprintf(stdout, "0x%08x ", context[i]);
            }
            fprintf(stdout, "\n");

         }
         aub_write_ggtt(&aub, bo_entry->addr, bo_entry->size, bo_entry->data);
         break;
      case BO_TYPE_RINGBUFFER:
      case BO_TYPE_STATUS:
      case BO_TYPE_CONTEXT_WA:
         aub_write_ggtt(&aub, bo_entry->addr, bo_entry->size, bo_entry->data);
         break;
      case BO_TYPE_UNKNOWN:
         if (bo_entry->gtt == PPGTT) {
            aub_map_ppgtt(&aub, bo_entry->addr, bo_entry->size);
            if (bo_entry->data) {
               aub_write_trace_block(&aub, AUB_TRACE_TYPE_NOTYPE,
                                     bo_entry->data, bo_entry->size, bo_entry->addr);
            }
         } else {
            if (bo_entry->size > 0) {
               void *zero_data = calloc(1, bo_entry->size);
               aub_write_ggtt(&aub, bo_entry->addr, bo_entry->size, zero_data);
               free(zero_data);
            }
         }
         break;
      default:
         break;
      }
   }

   if (aub_use_execlists(&aub)) {
      fail_if(!hwsp_bo, "Failed to find Context buffer.\n");
      aub_write_context_execlists(&aub, hwsp_bo->addr + 4096 /* skip GuC page */, hwsp_bo->engine_class);
   } else {
      /* Use context id 0 -- if we are not using execlists it doesn't matter
       * anyway
       */
      aub_write_exec(&aub, 0, batch_bo->addr, 0, INTEL_ENGINE_CLASS_RENDER);
   }

   /* Cleanup */
   list_for_each_entry_safe(struct bo, bo_entry, &bo_list, link) {
      list_del(&bo_entry->link);
      free(bo_entry->data);
      free(bo_entry);
   }

   free(out_filename);
   free(line);
   if(err_file) {
      fclose(err_file);
   }
   if(aub.file) {
      aub_file_finish(&aub);
   } else if(aub_file) {
      fclose(aub_file);
   }
   return EXIT_SUCCESS;
}

/* vim: set ts=8 sw=8 tw=0 cino=:0,(0 noet :*/