src/intel/tools/error2aub.c

   1 /*
   2  * Copyright © 2018 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  */
  24
  25 #include <assert.h>
  26 #include <getopt.h>
  27 #include <inttypes.h>
  28 #include <signal.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <stdarg.h>
  33 #include <zlib.h>
  34
  35 #include "aub_write.h"
  36 #include "i915_drm.h"
  37 #include "intel_aub.h"
  38
  39 static void __attribute__ ((format(__printf__, 2, 3)))
  40 fail_if(int cond, const char *format, ...)
  41 {
  42    va_list args;
  43
  44    if (!cond)
  45       return;
  46
  47    va_start(args, format);
  48    vfprintf(stderr, format, args);
  49    va_end(args);
  50
  51    raise(SIGTRAP);
  52 }
  53
  54 #define fail(...) fail_if(true, __VA_ARGS__)
  55
  56 static int zlib_inflate(uint32_t **ptr, int len)
  57 {
  58    struct z_stream_s zstream;
  59    void *out;
  60    const uint32_t out_size = 128*4096;  /* approximate obj size */
  61
  62    memset(&zstream, 0, sizeof(zstream));
  63
  64    zstream.next_in = (unsigned char *)*ptr;
  65    zstream.avail_in = 4*len;
  66
  67    if (inflateInit(&zstream) != Z_OK)
  68       return 0;
  69
  70    out = malloc(out_size);
  71    zstream.next_out = out;
  72    zstream.avail_out = out_size;
  73
  74    do {
  75       switch (inflate(&zstream, Z_SYNC_FLUSH)) {
  76       case Z_STREAM_END:
  77          goto end;
  78       case Z_OK:
  79          break;
  80       default:
  81          inflateEnd(&zstream);
  82          return 0;
  83       }
  84
  85       if (zstream.avail_out)
  86          break;
  87
  88       out = realloc(out, 2*zstream.total_out);
  89       if (out == NULL) {
  90          inflateEnd(&zstream);
  91          return 0;
  92       }
  93
  94       zstream.next_out = (unsigned char *)out + zstream.total_out;
  95       zstream.avail_out = zstream.total_out;
  96    } while (1);
  97  end:
  98    inflateEnd(&zstream);
  99    free(*ptr);
 100    *ptr = out;
 101    return zstream.total_out / 4;
 102 }
 103
 104 static int ascii85_decode(const char *in, uint32_t **out, bool inflate)
 105 {
 106    int len = 0, size = 1024;
 107
 108    *out = realloc(*out, sizeof(uint32_t)*size);
 109    if (*out == NULL)
 110       return 0;
 111
 112    while (*in >= '!' && *in <= 'z') {
 113       uint32_t v = 0;
 114
 115       if (len == size) {
 116          size *= 2;
 117          *out = realloc(*out, sizeof(uint32_t)*size);
 118          if (*out == NULL)
 119             return 0;
 120       }
 121
 122       if (*in == 'z') {
 123          in++;
 124       } else {
 125          v += in[0] - 33; v *= 85;
 126          v += in[1] - 33; v *= 85;
 127          v += in[2] - 33; v *= 85;
 128          v += in[3] - 33; v *= 85;
 129          v += in[4] - 33;
 130          in += 5;
 131       }
 132       (*out)[len++] = v;
 133    }
 134
 135    if (!inflate)
 136       return len;
 137
 138    return zlib_inflate(out, len);
 139 }
 140
 141 static void
 142 print_help(const char *progname, FILE *file)
 143 {
 144    fprintf(file,
 145            "Usage: %s [OPTION]... [FILE]\n"
 146            "Convert an Intel GPU i915 error state to an aub file.\n"
 147            "  -h, --help          display this help and exit\n"
 148            "  -o, --output=FILE   the output aub file (default FILE.aub)\n",
 149            progname);
 150 }
 151
 152 int
 153 main(int argc, char *argv[])
 154 {
 155    int i, c;
 156    bool help = false;
 157    char *out_filename = NULL, *in_filename = NULL;
 158    const struct option aubinator_opts[] = {
 159       { "help",       no_argument,       NULL,     'h' },
 160       { "output",     required_argument, NULL,     'o' },
 161       { NULL,         0,                 NULL,     0 }
 162    };
 163
 164    i = 0;
 165    while ((c = getopt_long(argc, argv, "ho:", aubinator_opts, &i)) != -1) {
 166       switch (c) {
 167       case 'h':
 168          help = true;
 169          break;
 170       case 'o':
 171          out_filename = strdup(optarg);
 172          break;
 173       default:
 174          break;
 175       }
 176    }
 177
 178    if (optind < argc)
 179       in_filename = argv[optind++];
 180
 181    if (help || argc == 1 || !in_filename) {
 182       print_help(argv[0], stderr);
 183       return in_filename ? EXIT_SUCCESS : EXIT_FAILURE;
 184    }
 185
 186    if (out_filename == NULL) {
 187       int out_filename_size = strlen(in_filename) + 5;
 188       out_filename = malloc(out_filename_size);
 189       snprintf(out_filename, out_filename_size, "%s.aub", in_filename);
 190    }
 191
 192    FILE *err_file = fopen(in_filename, "r");
 193    fail_if(!err_file, "Failed to open error file \"%s\": %m\n", in_filename);
 194
 195    FILE *aub_file = fopen(out_filename, "w");
 196    fail_if(!aub_file, "Failed to open aub file \"%s\": %m\n", in_filename);
 197
 198    struct aub_file aub = {};
 199
 200    uint32_t active_ring = 0;
 201    int num_ring_bos = 0;
 202
 203    uint64_t batch_addr = 0;
 204
 205    enum bo_type {
 206       BO_TYPE_UNKNOWN = 0,
 207       BO_TYPE_BATCH,
 208       BO_TYPE_USER,
 209    } bo_type = BO_TYPE_UNKNOWN;
 210    uint64_t bo_addr = 0;
 211
 212    char *line = NULL;
 213    size_t line_size;
 214    while (getline(&line, &line_size, err_file) > 0) {
 215       const char *pci_id_start = strstr(line, "PCI ID");
 216       if (pci_id_start) {
 217          int pci_id;
 218          int matched = sscanf(line, "PCI ID: 0x%04x\n", &pci_id);
 219          fail_if(!matched, "Invalid error state file!\n");
 220
 221          aub_file_init(&aub, aub_file, pci_id);
 222          fail_if(!aub_use_execlists(&aub),
 223                  "%s currently only works on gen8+\n", argv[0]);
 224
 225          aub_write_header(&aub, "error state");
 226          continue;
 227       }
 228
 229       const char *active_start = "Active (";
 230       if (strncmp(line, active_start, strlen(active_start)) == 0) {
 231          fail_if(active_ring != 0, "TODO: Handle multiple active rings\n");
 232
 233          char *ring = line + strlen(active_start);
 234
 235          const struct {
 236             const char *match;
 237             uint32_t ring;
 238          } rings[] = {
 239             { "rcs", I915_EXEC_RENDER },
 240             { "vcs", I915_EXEC_VEBOX },
 241             { "bcs", I915_EXEC_BLT },
 242             { NULL, BO_TYPE_UNKNOWN },
 243          }, *r;
 244
 245          for (r = rings; r->match; r++) {
 246             if (strncasecmp(ring, r->match, strlen(r->match)) == 0) {
 247                active_ring = r->ring;
 248                break;
 249             }
 250          }
 251
 252          char *count = strchr(ring, '[');
 253          fail_if(!count || sscanf(count, "[%d]:", &num_ring_bos) < 1,
 254                  "Failed to parse BO table header\n");
 255          continue;
 256       }
 257
 258       if (num_ring_bos > 0) {
 259          unsigned hi, lo, size;
 260          if (sscanf(line, " %x_%x %d", &hi, &lo, &size) == 3) {
 261             assert(aub_use_execlists(&aub));
 262             aub_map_ppgtt(&aub, ((uint64_t)hi) << 32 | lo, size);
 263             num_ring_bos--;
 264          } else {
 265             fail("Not enough BO entries in the active table\n");
 266          }
 267          continue;
 268       }
 269
 270       if (line[0] == ':' || line[0] == '~') {
 271          if (bo_type == BO_TYPE_UNKNOWN)
 272             continue;
 273
 274          uint32_t *data = NULL;
 275          int count = ascii85_decode(line+1, &data, line[0] == ':');
 276          fail_if(count == 0, "ASCII85 decode failed.\n");
 277          uint64_t bo_size = count * 4;
 278
 279          if (bo_type == BO_TYPE_BATCH) {
 280             aub_write_trace_block(&aub, AUB_TRACE_TYPE_BATCH,
 281                                   data, bo_size, bo_addr);
 282             batch_addr = bo_addr;
 283          } else {
 284             assert(bo_type == BO_TYPE_USER);
 285             aub_write_trace_block(&aub, AUB_TRACE_TYPE_NOTYPE,
 286                                   data, bo_size, bo_addr);
 287          }
 288
 289          continue;
 290       }
 291
 292       char *dashes = strstr(line, "---");
 293       if (dashes) {
 294          dashes += 4;
 295
 296          const struct {
 297             const char *match;
 298             enum bo_type type;
 299          } bo_types[] = {
 300             { "gtt_offset", BO_TYPE_BATCH },
 301             { "user", BO_TYPE_USER },
 302             { NULL, BO_TYPE_UNKNOWN },
 303          }, *b;
 304
 305          bo_type = BO_TYPE_UNKNOWN;
 306          for (b = bo_types; b->match; b++) {
 307             if (strncasecmp(dashes, b->match, strlen(b->match)) == 0) {
 308                bo_type = b->type;
 309                break;
 310             }
 311          }
 312
 313          if (bo_type != BO_TYPE_UNKNOWN) {
 314             uint32_t hi, lo;
 315             dashes = strchr(dashes, '=');
 316             if (dashes && sscanf(dashes, "= 0x%08x %08x\n", &hi, &lo) == 2) {
 317                bo_addr = ((uint64_t) hi) << 32 | lo;
 318             } else {
 319                fail("User BO does not have an address\n");
 320             }
 321          }
 322          continue;
 323       }
 324    }
 325
 326    fail_if(!batch_addr, "Failed to find batch buffer.\n");
 327
 328    aub_write_exec(&aub, batch_addr, aub_gtt_size(&aub), I915_EXEC_RENDER);
 329
 330    free(out_filename);
 331    free(line);
 332    if(err_file) {
 333       fclose(err_file);
 334    }
 335    if(aub.file) {
 336       aub_file_finish(&aub);
 337    } else if(aub_file) {
 338       fclose(aub_file);
 339    }
 340    return EXIT_SUCCESS;
 341 }
 342
 343 /* vim: set ts=8 sw=8 tw=0 cino=:0,(0 noet :*/