| /* |
| * Copyright © 2023 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 <stdio.h> |
| #include <stdlib.h> |
| #include <stdint.h> |
| #include <getopt.h> |
| #include <unistd.h> |
| #include <fcntl.h> |
| #include <string.h> |
| #include <errno.h> |
| #include <sys/stat.h> |
| #include <sys/mman.h> |
| #include <sys/types.h> |
| #include <ctype.h> |
| |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include "util/list.h" |
| #include "util/macros.h" |
| |
| #include "common/intel_hang_dump.h" |
| |
| #include "compiler/brw_disasm.h" |
| #include "compiler/brw_isa_info.h" |
| #include "compiler/elk/elk_disasm.h" |
| #include "compiler/elk/elk_isa_info.h" |
| |
| /* Data */ |
| |
| struct hang_bo { |
| void *map = NULL; |
| uint64_t offset = 0; |
| uint64_t size = 0; |
| }; |
| |
| struct hang_map { |
| uint64_t offset = 0; |
| uint64_t size = 0; |
| }; |
| |
| struct hang_exec { |
| uint64_t offset = 0; |
| }; |
| |
| /* UI */ |
| |
| #include <epoxy/gl.h> |
| |
| #include "imgui/imgui.h" |
| #include "imgui/imgui_memory_editor.h" |
| #include "imgui_impl_gtk3.h" |
| #include "imgui_impl_opengl3.h" |
| |
| #include "aubinator_viewer.h" |
| |
| static int |
| map_key(int k) |
| { |
| return ImGuiKey_COUNT + k; |
| } |
| |
| static bool |
| has_ctrl_key(int key) |
| { |
| return ImGui::GetIO().KeyCtrl && ImGui::IsKeyPressed(map_key(key)); |
| } |
| |
| static bool |
| window_has_ctrl_key(int key) |
| { |
| return ImGui::IsRootWindowOrAnyChildFocused() && has_ctrl_key(key); |
| } |
| |
| class window { |
| public: |
| virtual void display() = 0; |
| virtual void destroy() = 0; |
| |
| virtual ~window() {} |
| |
| const char *name() const { return m_name; } |
| |
| bool m_opened = true; |
| |
| ImVec2 m_position = ImVec2(-1, -1); |
| ImVec2 m_size = ImVec2(700, 300); |
| |
| protected: |
| window() {} |
| |
| char m_name[128]; |
| }; |
| |
| static struct Context { |
| /* Hang file descriptor */ |
| int file_fd = -1; |
| void *file_map = NULL; |
| |
| /* Map hang file in RW for edition */ |
| bool edit = false; |
| |
| /* AUX-TT */ |
| uint64_t aux_tt_addr = 0; |
| |
| struct intel_device_info devinfo; |
| struct intel_spec *spec = NULL; |
| |
| struct brw_isa_info brw; |
| struct elk_isa_info elk; |
| |
| /* Result of parsing the hang file */ |
| std::vector<hang_bo> bos; |
| std::vector<hang_map> maps; |
| std::vector<hang_exec> execs; |
| |
| hang_bo hw_image; |
| |
| GtkWidget *gtk_window; |
| |
| /* UI state*/ |
| bool show_commands_window; |
| bool show_registers_window; |
| |
| struct aub_viewer_cfg cfg; |
| |
| std::vector<std::shared_ptr<window>> windows; |
| } context; |
| |
| thread_local ImGuiContext* __MesaImGui; |
| |
| hang_bo *find_bo(uint64_t addr) |
| { |
| for (auto &bo : context.bos) { |
| if (addr >= bo.offset && addr < (bo.offset + bo.size)) |
| return &bo; |
| } |
| return NULL; |
| } |
| |
| /**/ |
| |
| static uint8_t |
| read_edit_window(const uint8_t *data, size_t off) |
| { |
| return data[off]; |
| } |
| |
| static void |
| write_edit_window(uint8_t *data, size_t off, uint8_t d) |
| { |
| data[off] = d; |
| } |
| |
| class edit_window : public window { |
| public: |
| struct hang_bo m_bo; |
| |
| struct intel_batch_decode_bo m_aub_bo; |
| uint64_t m_aub_offset; |
| |
| struct intel_batch_decode_bo m_gtt_bo; |
| uint64_t m_gtt_offset; |
| |
| struct MemoryEditor m_editor; |
| |
| edit_window(const struct hang_bo &bo) |
| : m_bo(bo) { |
| m_editor.OptShowDataPreview = true; |
| m_editor.OptShowAscii = false; |
| m_editor.ReadFn = read_edit_window; |
| m_editor.WriteFn = write_edit_window; |
| |
| snprintf(m_name, sizeof(m_name), "Memory view 0x%016" PRIx64 "##%p", |
| bo.offset, this); |
| } |
| |
| void display() { |
| if (m_bo.map) { |
| ImGui::BeginChild(ImGui::GetID("##block")); |
| m_editor.DrawContents((uint8_t *) m_bo.map, m_bo.size, m_bo.offset); |
| ImGui::EndChild(); |
| } else { |
| ImGui::Text("Memory view at 0x%" PRIx64 " not available", m_bo.offset); |
| } |
| } |
| |
| void destroy() {} |
| }; |
| |
| class shader_window : public window { |
| public: |
| std::string m_description; |
| uint64_t m_address; |
| std::string m_shader; |
| |
| shader_window(const char *description, uint64_t address) |
| : m_description(description) |
| , m_address(address) { |
| snprintf(m_name, sizeof(m_name), |
| "%s (0x%" PRIx64 ")##%p", m_description.c_str(), m_address, this); |
| |
| hang_bo *bo = find_bo(address); |
| if (bo != NULL) { |
| char *shader_txt = NULL; |
| size_t shader_txt_size = 0; |
| FILE *f = open_memstream(&shader_txt, &shader_txt_size); |
| if (f) { |
| if (context.devinfo.ver >= 9) { |
| brw_disassemble_with_errors(&context.brw, |
| (const uint8_t *) bo->map + |
| (address - bo->offset), 0, f); |
| } else { |
| elk_disassemble_with_errors(&context.elk, |
| (const uint8_t *) bo->map + |
| (address - bo->offset), 0, f); |
| } |
| fclose(f); |
| } |
| |
| m_shader = std::string(shader_txt); |
| } |
| } |
| |
| void display() { |
| ImGui::InputTextMultiline("Assembly", |
| (char *) m_shader.c_str(), m_shader.size(), |
| ImGui::GetContentRegionAvail(), |
| ImGuiInputTextFlags_ReadOnly); |
| } |
| |
| void destroy() {} |
| }; |
| |
| class aux_tt_window : public window { |
| public: |
| aux_tt_window(uint64_t l3_addr) |
| : m_l3_addr(l3_addr) |
| , m_bo(find_bo(l3_addr)) { |
| snprintf(m_name, sizeof(m_name), "AUX TT##%p", this); |
| } |
| |
| void display() { |
| ImGui::BeginChild(ImGui::GetID("##toplevel")); |
| if (m_bo != NULL) |
| display_level(3, m_l3_addr, 0); |
| else |
| ImGui::Text("AUX table buffer not found: 0x%" PRIx64, |
| m_l3_addr); |
| ImGui::EndChild(); |
| } |
| |
| void destroy() {} |
| |
| private: |
| void display_level(int level, uint64_t table_addr, uint64_t base_addr) { |
| assert(level >= 1 && level <= 3); |
| |
| const hang_bo *bo = |
| table_addr == m_l3_addr ? m_bo : find_bo(table_addr); |
| if (bo == NULL) { |
| ImGui::Text("level %u not found addr=0x%016" PRIx64, |
| level, table_addr); |
| return; |
| } |
| |
| static struct { |
| uint32_t top; |
| uint32_t bottom; |
| } levels[4] = { |
| { 0, 0, }, |
| { 23, 16, }, |
| { 35, 24, }, |
| { 47, 36, }, |
| }; |
| |
| const uint64_t *entries = |
| (const uint64_t *)((const uint8_t *)bo->map + (table_addr - bo->offset)); |
| |
| if (level == 1) { |
| uint32_t n_entries = context.devinfo.verx10 == 125 ? 16 : 256; |
| for (uint32_t i = 0; i < n_entries; i++) { |
| uint64_t addr = entries[i] & 0xffffffffff00ull; |
| ImGui::Text("entry%04u: addr=0x%012" PRIx64 " entry=0x%012" PRIx64 |
| " range=0x%012" PRIx64 "-0x%012" PRIx64, |
| i, addr, entries[i], |
| base_addr + (uint64_t)i << levels[level].bottom, |
| base_addr + (uint64_t)i << levels[level].bottom); |
| } |
| } else { |
| for (uint32_t i = 0; i < 4096; i++) { |
| uint64_t entry_addr = base_addr + (uint64_t)i << levels[level].bottom; |
| uint64_t addr = entries[i] & 0xffffffff8000ull; |
| bool valid = (entries[i] & 0x1) != 0; |
| if (valid && |
| ImGui::TreeNodeEx( |
| (void *)&entries[i], |
| ImGuiTreeNodeFlags_Framed, |
| "entry%04u: addr=0x%012" PRIx64 " entry=0x%012" PRIx64 |
| " range=0x%012" PRIx64 "-0x%012" PRIx64, |
| i, addr, entries[i], |
| entry_addr, entry_addr)) { |
| if (valid) |
| display_level(level - 1, addr, entry_addr); |
| ImGui::TreePop(); |
| } |
| } |
| } |
| } |
| |
| uint64_t m_l3_addr; |
| const hang_bo *m_bo; |
| }; |
| |
| static struct intel_batch_decode_bo |
| batch_get_bo(void *user_data, bool ppgtt, uint64_t address) |
| { |
| intel_batch_decode_bo ret_bo; |
| ret_bo.map = NULL; |
| ret_bo.addr = 0; |
| |
| if (!ppgtt) |
| return ret_bo; |
| |
| for (const auto &bo : context.bos) { |
| if (address >= bo.offset && |
| address < (bo.offset + bo.size)) { |
| ret_bo.map = bo.map; |
| ret_bo.addr = bo.offset; |
| ret_bo.size = bo.size; |
| } |
| } |
| |
| return ret_bo; |
| } |
| |
| static void |
| batch_display_shader(void *user_data, const char *shader_desc, uint64_t address) |
| { |
| context.windows.push_back(std::shared_ptr<window>(new shader_window(shader_desc, address))); |
| } |
| |
| class batch_window : public window { |
| public: |
| batch_window(const struct hang_bo &bo) |
| : m_bo(bo) |
| , m_collapsed(true) { |
| aub_viewer_decode_ctx_init(&m_decode_ctx, |
| &context.cfg, |
| &m_decode_cfg, |
| &context.devinfo, |
| context.spec, |
| batch_get_bo, |
| NULL, |
| NULL); |
| m_decode_ctx.display_shader = batch_display_shader; |
| // window->decode_ctx.display_urb = batch_display_urb; |
| // window->decode_ctx.edit_address = batch_edit_address; |
| |
| snprintf(m_name, sizeof(m_name), "Batch view 0x%016" PRIx64 "##%p", |
| bo.offset, this); |
| } |
| ~batch_window() {} |
| |
| void display() { |
| ImGui::PushItemWidth(ImGui::GetContentRegionAvailWidth() / (2 * 2)); |
| decode_options(); |
| if (ImGui::Button("Edit commands")) |
| context.windows.push_back(std::shared_ptr<window>(new edit_window(m_bo))); |
| ImGui::PopItemWidth(); |
| |
| ImGui::BeginChild(ImGui::GetID("##block")); |
| |
| aub_viewer_render_batch(&m_decode_ctx, |
| m_bo.map, |
| m_bo.size, |
| m_bo.offset, |
| false /* from_ring */); |
| |
| ImGui::EndChild(); |
| } |
| |
| void destroy() {} |
| |
| private: |
| |
| void decode_options() { |
| char name[40]; |
| snprintf(name, sizeof(name), "command filter##%p", &m_decode_cfg.command_filter); |
| m_decode_cfg.command_filter.Draw(name); ImGui::SameLine(); |
| snprintf(name, sizeof(name), "field filter##%p", &m_decode_cfg.field_filter); |
| m_decode_cfg.field_filter.Draw(name); ImGui::SameLine(); |
| if (ImGui::Button("Dwords")) m_decode_cfg.show_dwords ^= 1; |
| } |
| |
| struct hang_bo m_bo; |
| |
| bool m_collapsed; |
| |
| struct aub_viewer_decode_cfg m_decode_cfg; |
| struct aub_viewer_decode_ctx m_decode_ctx; |
| |
| char edit_address[20]; |
| }; |
| |
| /* Main window */ |
| |
| static const char * |
| human_size(size_t size) |
| { |
| unsigned divisions = 0; |
| double v = size; |
| double divider = 1024; |
| while (v >= divider) { |
| v /= divider; |
| divisions++; |
| } |
| |
| static const char *units[] = { "Bytes", "Kilobytes", "Megabytes", "Gigabytes" }; |
| static char result[20]; |
| snprintf(result, sizeof(result), "%.2f %s", |
| v, divisions >= ARRAY_SIZE(units) ? "Too much!" : units[divisions]); |
| return result; |
| } |
| |
| static void |
| display_hang_stats() |
| { |
| ImGui::Begin("Hang stats"); |
| |
| ImGuiColorEditFlags cflags = (ImGuiColorEditFlags_NoAlpha | |
| ImGuiColorEditFlags_NoLabel | |
| ImGuiColorEditFlags_NoInputs); |
| struct aub_viewer_cfg *cfg = &context.cfg; |
| |
| ImGui::ColorEdit3("background", (float *)&cfg->clear_color, cflags); ImGui::SameLine(); |
| ImGui::ColorEdit3("missing", (float *)&cfg->missing_color, cflags); ImGui::SameLine(); |
| ImGui::ColorEdit3("error", (float *)&cfg->error_color, cflags); ImGui::SameLine(); |
| ImGui::ColorEdit3("highlight", (float *)&cfg->highlight_color, cflags); ImGui::SameLine(); |
| ImGui::ColorEdit3("dwords", (float *)&cfg->dwords_color, cflags); ImGui::SameLine(); |
| ImGui::ColorEdit3("booleans", (float *)&cfg->boolean_color, cflags); ImGui::SameLine(); |
| |
| if (ImGui::Button("Help") || has_ctrl_key('h')) { ImGui::OpenPopup("Help"); } |
| |
| ImGui::Text("BOs: %zu", context.bos.size()); |
| ImGui::Text("Execs %zu", context.execs.size()); |
| ImGui::Text("Maps: %zu", context.maps.size()); |
| ImGui::Text("PCI ID: 0x%x", context.devinfo.pci_device_id); |
| |
| ImGui::SetNextWindowContentWidth(500); |
| if (ImGui::BeginPopupModal("Help", NULL, ImGuiWindowFlags_AlwaysAutoResize)) { |
| ImGui::Text("Some global keybindings:"); |
| ImGui::Separator(); |
| |
| static const char *texts[] = { |
| "Ctrl-h", "show this screen", |
| "Ctrl-c", "show commands list", |
| "Ctrl-r", "show registers list", |
| "Ctrl-b", "new batch window", |
| "Ctrl-p/n", "switch to previous/next batch buffer", |
| "Ctrl-Tab", "switch focus between window", |
| "Ctrl-left/right", "align window to the side of the screen", |
| }; |
| float align = 0.0f; |
| for (uint32_t i = 0; i < ARRAY_SIZE(texts); i += 2) |
| align = MAX2(align, ImGui::CalcTextSize(texts[i]).x); |
| align += ImGui::GetStyle().WindowPadding.x + 10; |
| |
| for (uint32_t i = 0; i < ARRAY_SIZE(texts); i += 2) { |
| ImGui::Text("%s", texts[i]); ImGui::SameLine(align); ImGui::Text("%s", texts[i + 1]); |
| } |
| |
| if (ImGui::Button("Done") || ImGui::IsKeyPressed(ImGuiKey_Escape)) |
| ImGui::CloseCurrentPopup(); |
| ImGui::EndPopup(); |
| } |
| |
| uint64_t exec_buf_addr = 0; |
| if (!context.execs.empty()) |
| exec_buf_addr = context.execs.front().offset; |
| |
| ImGui::BeginChild(ImGui::GetID("BO list:")); |
| for (const auto &bo : context.bos) { |
| char bo_name[80]; |
| snprintf(bo_name, sizeof(bo_name), |
| "BO 0x%012" PRIx64 "-0x%012" PRIx64 " size=%" PRIu64 "(%s) %s", |
| bo.offset, bo.offset + bo.size - 1, bo.size, human_size(bo.size), |
| bo.offset == exec_buf_addr ? "BATCH BUFFER" : ""); |
| |
| if (ImGui::Selectable(bo_name, false)) |
| context.windows.push_back(std::shared_ptr<window>(new batch_window(bo))); |
| } |
| if (context.hw_image.size != 0 && ImGui::Selectable("HW IMAGE", false)) |
| context.windows.push_back(std::shared_ptr<window>(new batch_window(context.hw_image))); |
| if (context.aux_tt_addr != 0 && ImGui::Selectable("AUX-TT", false)) |
| context.windows.push_back(std::shared_ptr<window>(new aux_tt_window(context.aux_tt_addr))); |
| ImGui::EndChild(); |
| |
| ImGui::End(); |
| } |
| |
| /* Main redrawing */ |
| |
| static void |
| display_windows(void) |
| { |
| display_hang_stats(); |
| |
| /* Start by disposing closed windows, we don't want to destroy windows that |
| * have already been scheduled to be painted. So destroy always happens on |
| * the next draw cycle, prior to any drawing. |
| */ |
| auto it = context.windows.begin(); |
| while (it != context.windows.end()) { |
| if (!(*it)->m_opened) { |
| (*it)->destroy(); |
| it = context.windows.erase(it); |
| } else { |
| it++; |
| } |
| } |
| |
| for (uint32_t i = 0; i < context.windows.size(); i++) { |
| std::shared_ptr<window> window = context.windows[i]; |
| ImGui::SetNextWindowPos(window->m_position, ImGuiCond_FirstUseEver); |
| ImGui::SetNextWindowSize(window->m_size, ImGuiCond_FirstUseEver); |
| if (ImGui::Begin(window->name(), &window->m_opened)) { |
| window->display(); |
| window->m_position = ImGui::GetWindowPos(); |
| window->m_size = ImGui::GetWindowSize(); |
| } |
| if (window_has_ctrl_key('w')) |
| window->m_opened = false; |
| ImGui::End(); |
| } |
| } |
| |
| static void |
| repaint_area(GtkGLArea *area, GdkGLContext *gdk_gl_context) |
| { |
| ImGui_ImplOpenGL3_NewFrame(); |
| ImGui_ImplGtk3_NewFrame(); |
| ImGui::NewFrame(); |
| |
| display_windows(); |
| |
| ImGui::EndFrame(); |
| ImGui::Render(); |
| |
| glClearColor(context.cfg.clear_color.Value.x, |
| context.cfg.clear_color.Value.y, |
| context.cfg.clear_color.Value.z, 1.0); |
| glClear(GL_COLOR_BUFFER_BIT); |
| ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData()); |
| } |
| |
| static void |
| realize_area(GtkGLArea *area) |
| { |
| ImGui::CreateContext(); |
| ImGui_ImplGtk3_Init(GTK_WIDGET(area), true); |
| ImGui_ImplOpenGL3_Init("#version 130"); |
| |
| ImGui::StyleColorsDark(); |
| context.cfg = aub_viewer_cfg(); |
| |
| ImGuiIO& io = ImGui::GetIO(); |
| io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; |
| } |
| |
| static void |
| unrealize_area(GtkGLArea *area) |
| { |
| gtk_gl_area_make_current(area); |
| |
| ImGui_ImplOpenGL3_Shutdown(); |
| ImGui_ImplGtk3_Shutdown(); |
| ImGui::DestroyContext(); |
| } |
| |
| static void |
| size_allocate_area(GtkGLArea *area, |
| GdkRectangle *allocation, |
| gpointer user_data) |
| { |
| if (!gtk_widget_get_realized(GTK_WIDGET(area))) |
| return; |
| |
| /* We want to catch only initial size allocate. */ |
| g_signal_handlers_disconnect_by_func(area, |
| (gpointer) size_allocate_area, |
| user_data); |
| // TODO |
| } |
| |
| static void |
| print_help(const char *progname, FILE *file) |
| { |
| fprintf(file, |
| "Usage: %s -p platform HANG_FILE\n" |
| "\n" |
| " -p, --platform platform platform to use for decoding\n" |
| " -e, --edit map the hang file read/write for edition\n" |
| " -x, --aux-tt map the hang file read/write for edition\n" |
| , progname); |
| } |
| |
| static void |
| add_bo(void *map, uint64_t addr, uint64_t size) |
| { |
| hang_bo bo; |
| bo.map = map; |
| bo.offset = addr; |
| bo.size = size; |
| context.bos.push_back(bo); |
| } |
| |
| static void |
| add_map(uint64_t addr, uint64_t size) |
| { |
| hang_map map; |
| map.offset = addr; |
| map.size = size; |
| context.maps.push_back(map); |
| } |
| |
| static void |
| add_exec(uint64_t addr) |
| { |
| hang_exec exec; |
| exec.offset = addr; |
| context.execs.push_back(exec); |
| } |
| |
| static size_t |
| get_block_size(uint32_t type) |
| { |
| switch (type) { |
| case INTEL_HANG_DUMP_BLOCK_TYPE_HEADER: return sizeof(struct intel_hang_dump_block_header); |
| case INTEL_HANG_DUMP_BLOCK_TYPE_BO: return sizeof(struct intel_hang_dump_block_bo); |
| case INTEL_HANG_DUMP_BLOCK_TYPE_MAP: return sizeof(struct intel_hang_dump_block_map); |
| case INTEL_HANG_DUMP_BLOCK_TYPE_EXEC: return sizeof(struct intel_hang_dump_block_exec); |
| case INTEL_HANG_DUMP_BLOCK_TYPE_HW_IMAGE: return sizeof(struct intel_hang_dump_block_hw_image); |
| default: unreachable("invalid block"); |
| } |
| } |
| |
| static void |
| parse_hang_file(const char *filename) |
| { |
| context.file_fd = open(filename, context.edit ? O_RDWR : O_RDONLY); |
| if (context.file_fd < 0) |
| exit(EXIT_FAILURE); |
| |
| struct stat file_stats; |
| if (fstat(context.file_fd, &file_stats) != 0) |
| exit(EXIT_FAILURE); |
| |
| context.file_map = mmap(NULL, file_stats.st_size, |
| PROT_READ | PROT_WRITE, |
| context.edit ? MAP_SHARED : MAP_PRIVATE, |
| context.file_fd, 0); |
| if (context.file_map == MAP_FAILED) |
| exit(EXIT_FAILURE); |
| |
| uint8_t *current_file_ptr = (uint8_t *) context.file_map; |
| uint8_t *last_file_ptr = current_file_ptr + file_stats.st_size; |
| |
| while (current_file_ptr < last_file_ptr) { |
| union intel_hang_dump_block_all *block_header = |
| (union intel_hang_dump_block_all *)current_file_ptr; |
| size_t block_size = get_block_size(block_header->base.type); |
| |
| switch (block_header->base.type) { |
| case INTEL_HANG_DUMP_BLOCK_TYPE_HEADER: |
| assert(block_header->header.magic == INTEL_HANG_DUMP_MAGIC); |
| assert(block_header->header.version == INTEL_HANG_DUMP_VERSION); |
| break; |
| |
| case INTEL_HANG_DUMP_BLOCK_TYPE_BO: { |
| add_bo((uint8_t *) current_file_ptr + block_size, |
| block_header->bo.offset, |
| block_header->bo.size); |
| current_file_ptr = (uint8_t *) current_file_ptr + block_size + block_header->bo.size; |
| break; |
| } |
| |
| case INTEL_HANG_DUMP_BLOCK_TYPE_HW_IMAGE: { |
| context.hw_image.offset = block_header->bo.offset; |
| context.hw_image.size = block_header->hw_img.size; |
| context.hw_image.map = (uint8_t *) current_file_ptr + block_size; |
| current_file_ptr = (uint8_t *) current_file_ptr + block_size + block_header->hw_img.size; |
| break; |
| } |
| |
| case INTEL_HANG_DUMP_BLOCK_TYPE_MAP: { |
| add_map(block_header->map.offset, |
| block_header->map.size); |
| current_file_ptr = (uint8_t *) current_file_ptr + block_size; |
| break; |
| } |
| |
| case INTEL_HANG_DUMP_BLOCK_TYPE_EXEC: { |
| add_exec(block_header->exec.offset); |
| current_file_ptr = (uint8_t *) current_file_ptr + block_size; |
| break; |
| } |
| |
| default: |
| unreachable("Invalid block type"); |
| } |
| } |
| } |
| |
| int |
| main(int argc, char *argv[]) |
| { |
| int c, i; |
| bool help = false; |
| const char *platform = NULL; |
| const struct option aubinator_opts[] = { |
| { "platform", required_argument, NULL, 'p' }, |
| { "aux-tt", required_argument, NULL, 'x' }, |
| { "edit", no_argument, NULL, 'e' }, |
| { "help", no_argument, (int *) &help, true }, |
| { NULL, 0, NULL, 0 }, |
| }; |
| |
| context = {}; |
| |
| i = 0; |
| while ((c = getopt_long(argc, argv, "p:ex:", aubinator_opts, &i)) != -1) { |
| switch (c) { |
| case 'p': |
| platform = optarg; |
| break; |
| case 'e': |
| context.edit = true; |
| break; |
| case 'x': |
| context.aux_tt_addr = strtoll(optarg, NULL, 16); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| const char *filename = NULL; |
| if (optind < argc) |
| filename = argv[optind]; |
| |
| if (help || !platform || !filename) { |
| print_help(argv[0], stderr); |
| exit(0); |
| } |
| |
| intel_get_device_info_from_pci_id( |
| intel_device_name_to_pci_device_id(platform), |
| &context.devinfo); |
| |
| if (context.devinfo.ver >= 9) { |
| brw_init_isa_info(&context.brw, &context.devinfo); |
| } else { |
| elk_init_isa_info(&context.elk, &context.devinfo); |
| } |
| context.spec = intel_spec_load(&context.devinfo); |
| |
| parse_hang_file(filename); |
| |
| gtk_init(NULL, NULL); |
| |
| context.gtk_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); |
| gtk_window_set_title(GTK_WINDOW(context.gtk_window), "Hang Viewer"); |
| g_signal_connect(context.gtk_window, "delete-event", G_CALLBACK(gtk_main_quit), NULL); |
| gtk_window_resize(GTK_WINDOW(context.gtk_window), 1280, 720); |
| |
| GtkWidget* gl_area = gtk_gl_area_new(); |
| g_signal_connect(gl_area, "render", G_CALLBACK(repaint_area), NULL); |
| g_signal_connect(gl_area, "realize", G_CALLBACK(realize_area), NULL); |
| g_signal_connect(gl_area, "unrealize", G_CALLBACK(unrealize_area), NULL); |
| g_signal_connect(gl_area, "size_allocate", G_CALLBACK(size_allocate_area), NULL); |
| gtk_container_add(GTK_CONTAINER(context.gtk_window), gl_area); |
| |
| gtk_widget_show_all(context.gtk_window); |
| |
| gtk_main(); |
| |
| return EXIT_SUCCESS; |
| } |
