summaryrefslogtreecommitdiff
path: root/tools/aubdump.c
diff options
context:
space:
mode:
Diffstat (limited to 'tools/aubdump.c')
-rw-r--r--tools/aubdump.c518
1 files changed, 518 insertions, 0 deletions
diff --git a/tools/aubdump.c b/tools/aubdump.c
new file mode 100644
index 00000000..bf128531
--- /dev/null
+++ b/tools/aubdump.c
@@ -0,0 +1,518 @@
+/*
+ * Copyright © 2015 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.
+ */
+
+#define _GNU_SOURCE /* for RTLD_NEXT */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdarg.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/mman.h>
+#include <dlfcn.h>
+#include <drm/i915_drm.h>
+
+#include "intel_aub.h"
+#include "intel_chipset.h"
+
+static int (*libc_open)(const char *pathname, int flags, mode_t mode);
+static int (*libc_close)(int fd);
+static int (*libc_ioctl)(int fd, unsigned long request, void *argp);
+
+static int drm_fd = -1;
+static char *filename;
+static FILE *file;
+static int gen = 0;
+static int verbose = 0;
+static const uint32_t gtt_size = 0x10000;
+
+#define MAX_BO_COUNT 64 * 1024
+
+struct bo {
+ uint32_t size;
+ uint32_t offset;
+ void *map;
+};
+
+static struct bo *bos;
+
+#define DRM_MAJOR 226
+
+/* We set bit 0 in the map pointer for userptr BOs so we know not to
+ * munmap them on DRM_IOCTL_GEM_CLOSE.
+ */
+#define USERPTR_FLAG 1
+#define IS_USERPTR(p) ((uintptr_t) (p) & USERPTR_FLAG)
+#define GET_PTR(p) ( (void *) ((uintptr_t) p & ~(uintptr_t) 1) )
+
+static void __attribute__ ((format(__printf__, 2, 3)))
+fail_if(int cond, const char *format, ...)
+{
+ va_list args;
+
+ if (!cond)
+ return;
+
+ va_start(args, format);
+ vfprintf(stderr, format, args);
+ va_end(args);
+
+ exit(1);
+}
+
+static inline uint32_t
+align_u32(uint32_t v, uint32_t a)
+{
+ return (v + a - 1) & ~(a - 1);
+}
+
+static void
+dword_out(uint32_t data)
+{
+ fwrite(&data, 1, 4, file);
+}
+
+static void
+data_out(const void *data, size_t size)
+{
+ fwrite(data, 1, size, file);
+}
+
+static void
+write_header(void)
+{
+ uint32_t entry = 0x200003;
+
+ /* Start with a (required) version packet. */
+ dword_out(CMD_AUB_HEADER | (13 - 2));
+ dword_out((4 << AUB_HEADER_MAJOR_SHIFT) |
+ (0 << AUB_HEADER_MINOR_SHIFT));
+ for (int i = 0; i < 8; i++)
+ dword_out(0); /* app name */
+
+ dword_out(0); /* timestamp */
+ dword_out(0); /* timestamp */
+ dword_out(0); /* comment len */
+
+ /* Set up the GTT. The max we can handle is 256M */
+ dword_out(CMD_AUB_TRACE_HEADER_BLOCK | ((gen >= 8 ? 6 : 5) - 2));
+ dword_out(AUB_TRACE_MEMTYPE_GTT_ENTRY |
+ AUB_TRACE_TYPE_NOTYPE | AUB_TRACE_OP_DATA_WRITE);
+ dword_out(0); /* subtype */
+ dword_out(0); /* offset */
+ dword_out(gtt_size); /* size */
+ if (gen >= 8)
+ dword_out(0);
+ for (uint32_t i = 0; i < gtt_size; i += 4, entry += 0x1000)
+ dword_out(entry);
+}
+
+/**
+ * Break up large objects into multiple writes. Otherwise a 128kb VBO
+ * would overflow the 16 bits of size field in the packet header and
+ * everything goes badly after that.
+ */
+static void
+aub_write_trace_block(uint32_t type, void *virtual, uint32_t size, uint32_t gtt_offset)
+{
+ uint32_t block_size;
+ uint32_t subtype = 0;
+ static const char null_block[8 * 4096];
+
+ for (uint32_t offset = 0; offset < size; offset += block_size) {
+ block_size = size - offset;
+
+ if (block_size > 8 * 4096)
+ block_size = 8 * 4096;
+
+ dword_out(CMD_AUB_TRACE_HEADER_BLOCK |
+ ((gen >= 8 ? 6 : 5) - 2));
+ dword_out(AUB_TRACE_MEMTYPE_GTT |
+ type | AUB_TRACE_OP_DATA_WRITE);
+ dword_out(subtype);
+ dword_out(gtt_offset + offset);
+ dword_out(align_u32(block_size, 4));
+ if (gen >= 8)
+ dword_out(0);
+
+ if (virtual)
+ data_out(GET_PTR(virtual) + offset, block_size);
+ else
+ data_out(null_block, block_size);
+
+ /* Pad to a multiple of 4 bytes. */
+ data_out(null_block, -block_size & 3);
+ }
+}
+
+static void
+aub_dump_ringbuffer(uint32_t batch_offset, uint32_t offset, int ring_flag)
+{
+ uint32_t ringbuffer[4096];
+ int ring = AUB_TRACE_TYPE_RING_PRB0; /* The default ring */
+ int ring_count = 0;
+
+ if (ring_flag == I915_EXEC_BSD)
+ ring = AUB_TRACE_TYPE_RING_PRB1;
+ else if (ring_flag == I915_EXEC_BLT)
+ ring = AUB_TRACE_TYPE_RING_PRB2;
+
+ /* Make a ring buffer to execute our batchbuffer. */
+ memset(ringbuffer, 0, sizeof(ringbuffer));
+ if (gen >= 8) {
+ ringbuffer[ring_count++] = AUB_MI_BATCH_BUFFER_START | (3 - 2);
+ ringbuffer[ring_count++] = batch_offset;
+ ringbuffer[ring_count++] = 0;
+ } else {
+ ringbuffer[ring_count++] = AUB_MI_BATCH_BUFFER_START;
+ ringbuffer[ring_count++] = batch_offset;
+ }
+
+ /* Write out the ring. This appears to trigger execution of
+ * the ring in the simulator.
+ */
+ dword_out(CMD_AUB_TRACE_HEADER_BLOCK |
+ ((gen >= 8 ? 6 : 5) - 2));
+ dword_out(AUB_TRACE_MEMTYPE_GTT | ring | AUB_TRACE_OP_COMMAND_WRITE);
+ dword_out(0); /* general/surface subtype */
+ dword_out(offset);
+ dword_out(ring_count * 4);
+ if (gen >= 8)
+ dword_out(0);
+
+ data_out(ringbuffer, ring_count * 4);
+}
+
+static void *
+relocate_bo(struct bo *bo, const struct drm_i915_gem_execbuffer2 *execbuffer2,
+ const struct drm_i915_gem_exec_object2 *obj)
+{
+ const struct drm_i915_gem_exec_object2 *exec_objects =
+ (struct drm_i915_gem_exec_object2 *) (uintptr_t) execbuffer2->buffers_ptr;
+ const struct drm_i915_gem_relocation_entry *relocs =
+ (const struct drm_i915_gem_relocation_entry *) (uintptr_t) obj->relocs_ptr;
+ void *relocated;
+ uint32_t *dw;
+ int handle;
+
+ relocated = malloc(bo->size);
+ fail_if(relocated == NULL, "intel_aubdump: out of memory\n");
+ memcpy(relocated, GET_PTR(bo->map), bo->size);
+ for (size_t i = 0; i < obj->relocation_count; i++) {
+ fail_if(relocs[i].offset >= bo->size, "intel_aubdump: reloc outside bo\n");
+
+ if (execbuffer2->flags & I915_EXEC_HANDLE_LUT)
+ handle = exec_objects[relocs[i].target_handle].handle;
+ else
+ handle = relocs[i].target_handle;
+
+ dw = relocated + relocs[i].offset;
+ *dw = bos[handle].offset + relocs[i].delta;
+ }
+
+ return relocated;
+}
+
+static int
+gem_ioctl(int fd, unsigned long request, void *argp)
+{
+ int ret;
+
+ do {
+ ret = libc_ioctl(fd, request, argp);
+ } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+
+ return ret;
+}
+
+static void *
+gem_mmap(int fd, uint32_t handle, uint64_t offset, uint64_t size)
+{
+ struct drm_i915_gem_mmap mmap = {
+ .handle = handle,
+ .offset = offset,
+ .size = size
+ };
+
+ if (gem_ioctl(fd, DRM_IOCTL_I915_GEM_MMAP, &mmap) == -1)
+ return MAP_FAILED;
+
+ return (void *)(uintptr_t) mmap.addr_ptr;
+}
+
+static int
+gem_get_param(int fd, uint32_t param)
+{
+ int value;
+ drm_i915_getparam_t gp = {
+ .param = param,
+ .value = &value
+ };
+
+ if (gem_ioctl(fd, DRM_IOCTL_I915_GETPARAM, &gp) == -1)
+ return 0;
+
+ return value;
+}
+
+static void
+dump_execbuffer2(int fd, struct drm_i915_gem_execbuffer2 *execbuffer2)
+{
+ struct drm_i915_gem_exec_object2 *exec_objects =
+ (struct drm_i915_gem_exec_object2 *) (uintptr_t) execbuffer2->buffers_ptr;
+ uint32_t ring_flag = 0;
+ uint32_t offset = gtt_size;
+ struct drm_i915_gem_exec_object2 *obj;
+ struct bo *bo, *batch_bo;
+ void *data;
+
+ /* We can't do this at open time as we're not yet authenticated. */
+ if (gen == 0) {
+ uint32_t chipset_id = gem_get_param(fd, I915_PARAM_CHIPSET_ID);
+ gen = intel_gen(chipset_id);
+
+ fail_if(chipset_id == 0 || gen == -1, "failed to identify chipset\n");
+ if (verbose)
+ printf("[intel_aubdump active: "
+ "output file %s, chipset id 0x%04x, gen %d]\n",
+ filename, chipset_id, gen);
+ }
+
+ for (uint32_t i = 0; i < execbuffer2->buffer_count; i++) {
+ obj = &exec_objects[i];
+ bo = &bos[obj->handle];
+
+ bo->offset = offset;
+ offset = align_u32(offset + bo->size + 4095, 4096);
+
+ if (bo->map == NULL)
+ bo->map = gem_mmap(fd, obj->handle, 0, bo->size);
+ fail_if(bo->map == MAP_FAILED, "intel_aubdump: bo mmap failed\n");
+ }
+
+ batch_bo = &bos[exec_objects[execbuffer2->buffer_count - 1].handle];
+ for (uint32_t i = 0; i < execbuffer2->buffer_count; i++) {
+ obj = &exec_objects[i];
+ bo = &bos[obj->handle];
+
+ if (obj->relocation_count > 0)
+ data = relocate_bo(bo, execbuffer2, obj);
+ else
+ data = bo->map;
+
+ if (bo == batch_bo) {
+ aub_write_trace_block(AUB_TRACE_TYPE_BATCH,
+ data, bo->size, bo->offset);
+ } else {
+ aub_write_trace_block(AUB_TRACE_TYPE_NOTYPE,
+ data, bo->size, bo->offset);
+ }
+ if (data != bo->map)
+ free(data);
+ }
+
+ /* Dump ring buffer */
+ aub_dump_ringbuffer(batch_bo->offset + execbuffer2->batch_start_offset,
+ offset, ring_flag);
+
+ fflush(file);
+}
+
+static void
+add_new_bo(int handle, uint64_t size, void *map)
+{
+ struct bo *bo = &bos[handle];
+
+ fail_if(handle >= MAX_BO_COUNT, "intel_aubdump: bo handle out of range\n");
+
+ bo->size = size;
+ bo->map = map;
+}
+
+static void
+remove_bo(int handle)
+{
+ struct bo *bo = &bos[handle];
+
+ if (bo->map && !IS_USERPTR(bo->map))
+ munmap(bo->map, bo->size);
+ bo->map = NULL;
+}
+
+int
+open(const char *pathname, int flags, ...)
+{
+ va_list args;
+ struct stat buf;
+ mode_t mode;
+ int fd;
+
+ va_start(args, flags);
+ mode = va_arg(args, int);
+ va_end(args);
+
+ fd = libc_open(pathname, flags, mode);
+
+ if (fd >= 0 && fstat(fd, &buf) == 0 &&
+ (buf.st_mode & S_IFMT) == S_IFCHR && major(buf.st_rdev) == DRM_MAJOR)
+ drm_fd = fd;
+
+ return fd;
+}
+
+int
+close(int fd)
+{
+ if (fd == drm_fd)
+ drm_fd = -1;
+
+ return libc_close(fd);
+}
+
+int
+ioctl(int fd, unsigned long request, ...)
+{
+ va_list args;
+ void *argp;
+ int ret;
+
+ va_start(args, request);
+ argp = va_arg(args, void *);
+ va_end(args);
+
+ if (fd == drm_fd) {
+ switch (request) {
+ case DRM_IOCTL_I915_GEM_EXECBUFFER: {
+ static bool once;
+ if (!once) {
+ fprintf(stderr, "intel_aubdump: "
+ "application uses DRM_IOCTL_I915_GEM_EXECBUFFER, not handled\n");
+ once = true;
+ }
+ return libc_ioctl(fd, request, argp);
+ }
+
+ case DRM_IOCTL_I915_GEM_EXECBUFFER2: {
+ dump_execbuffer2(fd, argp);
+ return libc_ioctl(fd, request, argp);
+ }
+
+ case DRM_IOCTL_I915_GEM_CREATE: {
+ struct drm_i915_gem_create *create = argp;
+
+ ret = libc_ioctl(fd, request, argp);
+ if (ret == 0)
+ add_new_bo(create->handle, create->size, NULL);
+
+ return ret;
+ }
+
+ case DRM_IOCTL_I915_GEM_USERPTR: {
+ struct drm_i915_gem_userptr *userptr = argp;
+
+ ret = libc_ioctl(fd, request, argp);
+ if (ret == 0)
+ add_new_bo(userptr->handle, userptr->user_size,
+ (void *) (uintptr_t) (userptr->user_ptr | USERPTR_FLAG));
+ return ret;
+ }
+
+ case DRM_IOCTL_GEM_CLOSE: {
+ struct drm_gem_close *close = argp;
+
+ remove_bo(close->handle);
+
+ return libc_ioctl(fd, request, argp);
+ }
+
+ case DRM_IOCTL_GEM_OPEN: {
+ struct drm_gem_open *open = argp;
+
+ ret = libc_ioctl(fd, request, argp);
+ if (ret == 0)
+ add_new_bo(open->handle, open->size, NULL);
+
+ return ret;
+ }
+
+ case DRM_IOCTL_PRIME_FD_TO_HANDLE: {
+ struct drm_prime_handle *prime = argp;
+
+ ret = libc_ioctl(fd, request, argp);
+ if (ret == 0) {
+ off_t size;
+
+ size = lseek(prime->fd, 0, SEEK_END);
+ fail_if(size == -1, "intel_aubdump: failed to get prime bo size\n");
+ add_new_bo(prime->handle, size, NULL);
+ }
+
+ return ret;
+ }
+
+ default:
+ return libc_ioctl(fd, request, argp);
+ }
+ } else {
+ return libc_ioctl(fd, request, argp);
+ }
+}
+
+static void __attribute__ ((constructor))
+init(void)
+{
+ const char *args = getenv("INTEL_AUBDUMP_ARGS");
+
+ libc_open = dlsym(RTLD_NEXT, "open");
+ libc_close = dlsym(RTLD_NEXT, "close");
+ libc_ioctl = dlsym(RTLD_NEXT, "ioctl");
+ fail_if(libc_open == NULL || libc_close == NULL || libc_ioctl == NULL,
+ "intel_aubdump: failed to get libc open or ioctl\n");
+
+ if (sscanf(args, "verbose=%d;file=%m[^;]", &verbose, &filename) != 2)
+ filename = strdup("intel.aub");
+ fail_if(filename == NULL, "intel_aubdump: out of memory\n");
+
+ bos = malloc(MAX_BO_COUNT * sizeof(bos[0]));
+ fail_if(bos == NULL, "intel_aubdump: out of memory\n");
+
+ file = fopen(filename, "w+");
+ fail_if(file == NULL, "intel_aubdump: failed to open file '%s'\n", filename);
+
+ write_header();
+}
+
+static void __attribute__ ((destructor))
+fini(void)
+{
+ free(filename);
+ fclose(file);
+ free(bos);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-02 18:46:03 +0000