mirror of
https://github.com/Fishwaldo/Star64_linux.git
synced 2025-04-06 06:24:47 +00:00
76099f98ae
Add a report to display branches in a similar fashion to perf script. The main purpose of this report is to display disassembly, however, presently, the only supported disassembler is Intel XED, and additionally the object code must be present in perf build ID cache. To use Intel XED, libxed.so must be present. To build and install libxed.so: git clone https://github.com/intelxed/mbuild.git mbuild git clone https://github.com/intelxed/xed cd xed ./mfile.py --share sudo ./mfile.py --prefix=/usr/local install sudo ldconfig Signed-off-by: Adrian Hunter <adrian.hunter@intel.com> Cc: Andi Kleen <ak@linux.intel.com> Cc: Jiri Olsa <jolsa@redhat.com> Link: http://lkml.kernel.org/r/20181023075949.18920-1-adrian.hunter@intel.com Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2128 lines
64 KiB
Python
Executable file
2128 lines
64 KiB
Python
Executable file
#!/usr/bin/python2
|
|
# SPDX-License-Identifier: GPL-2.0
|
|
# exported-sql-viewer.py: view data from sql database
|
|
# Copyright (c) 2014-2018, Intel Corporation.
|
|
|
|
# To use this script you will need to have exported data using either the
|
|
# export-to-sqlite.py or the export-to-postgresql.py script. Refer to those
|
|
# scripts for details.
|
|
#
|
|
# Following on from the example in the export scripts, a
|
|
# call-graph can be displayed for the pt_example database like this:
|
|
#
|
|
# python tools/perf/scripts/python/exported-sql-viewer.py pt_example
|
|
#
|
|
# Note that for PostgreSQL, this script supports connecting to remote databases
|
|
# by setting hostname, port, username, password, and dbname e.g.
|
|
#
|
|
# python tools/perf/scripts/python/exported-sql-viewer.py "hostname=myhost username=myuser password=mypassword dbname=pt_example"
|
|
#
|
|
# The result is a GUI window with a tree representing a context-sensitive
|
|
# call-graph. Expanding a couple of levels of the tree and adjusting column
|
|
# widths to suit will display something like:
|
|
#
|
|
# Call Graph: pt_example
|
|
# Call Path Object Count Time(ns) Time(%) Branch Count Branch Count(%)
|
|
# v- ls
|
|
# v- 2638:2638
|
|
# v- _start ld-2.19.so 1 10074071 100.0 211135 100.0
|
|
# |- unknown unknown 1 13198 0.1 1 0.0
|
|
# >- _dl_start ld-2.19.so 1 1400980 13.9 19637 9.3
|
|
# >- _d_linit_internal ld-2.19.so 1 448152 4.4 11094 5.3
|
|
# v-__libc_start_main@plt ls 1 8211741 81.5 180397 85.4
|
|
# >- _dl_fixup ld-2.19.so 1 7607 0.1 108 0.1
|
|
# >- __cxa_atexit libc-2.19.so 1 11737 0.1 10 0.0
|
|
# >- __libc_csu_init ls 1 10354 0.1 10 0.0
|
|
# |- _setjmp libc-2.19.so 1 0 0.0 4 0.0
|
|
# v- main ls 1 8182043 99.6 180254 99.9
|
|
#
|
|
# Points to note:
|
|
# The top level is a command name (comm)
|
|
# The next level is a thread (pid:tid)
|
|
# Subsequent levels are functions
|
|
# 'Count' is the number of calls
|
|
# 'Time' is the elapsed time until the function returns
|
|
# Percentages are relative to the level above
|
|
# 'Branch Count' is the total number of branches for that function and all
|
|
# functions that it calls
|
|
|
|
# There is also a "All branches" report, which displays branches and
|
|
# possibly disassembly. However, presently, the only supported disassembler is
|
|
# Intel XED, and additionally the object code must be present in perf build ID
|
|
# cache. To use Intel XED, libxed.so must be present. To build and install
|
|
# libxed.so:
|
|
# git clone https://github.com/intelxed/mbuild.git mbuild
|
|
# git clone https://github.com/intelxed/xed
|
|
# cd xed
|
|
# ./mfile.py --share
|
|
# sudo ./mfile.py --prefix=/usr/local install
|
|
# sudo ldconfig
|
|
#
|
|
# Example report:
|
|
#
|
|
# Time CPU Command PID TID Branch Type In Tx Branch
|
|
# 8107675239590 2 ls 22011 22011 return from interrupt No ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea260 _start (ld-2.19.so)
|
|
# 7fab593ea260 48 89 e7 mov %rsp, %rdi
|
|
# 8107675239899 2 ls 22011 22011 hardware interrupt No 7fab593ea260 _start (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
|
|
# 8107675241900 2 ls 22011 22011 return from interrupt No ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea260 _start (ld-2.19.so)
|
|
# 7fab593ea260 48 89 e7 mov %rsp, %rdi
|
|
# 7fab593ea263 e8 c8 06 00 00 callq 0x7fab593ea930
|
|
# 8107675241900 2 ls 22011 22011 call No 7fab593ea263 _start+0x3 (ld-2.19.so) -> 7fab593ea930 _dl_start (ld-2.19.so)
|
|
# 7fab593ea930 55 pushq %rbp
|
|
# 7fab593ea931 48 89 e5 mov %rsp, %rbp
|
|
# 7fab593ea934 41 57 pushq %r15
|
|
# 7fab593ea936 41 56 pushq %r14
|
|
# 7fab593ea938 41 55 pushq %r13
|
|
# 7fab593ea93a 41 54 pushq %r12
|
|
# 7fab593ea93c 53 pushq %rbx
|
|
# 7fab593ea93d 48 89 fb mov %rdi, %rbx
|
|
# 7fab593ea940 48 83 ec 68 sub $0x68, %rsp
|
|
# 7fab593ea944 0f 31 rdtsc
|
|
# 7fab593ea946 48 c1 e2 20 shl $0x20, %rdx
|
|
# 7fab593ea94a 89 c0 mov %eax, %eax
|
|
# 7fab593ea94c 48 09 c2 or %rax, %rdx
|
|
# 7fab593ea94f 48 8b 05 1a 15 22 00 movq 0x22151a(%rip), %rax
|
|
# 8107675242232 2 ls 22011 22011 hardware interrupt No 7fab593ea94f _dl_start+0x1f (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
|
|
# 8107675242900 2 ls 22011 22011 return from interrupt No ffffffff86a00a67 native_irq_return_iret ([kernel]) -> 7fab593ea94f _dl_start+0x1f (ld-2.19.so)
|
|
# 7fab593ea94f 48 8b 05 1a 15 22 00 movq 0x22151a(%rip), %rax
|
|
# 7fab593ea956 48 89 15 3b 13 22 00 movq %rdx, 0x22133b(%rip)
|
|
# 8107675243232 2 ls 22011 22011 hardware interrupt No 7fab593ea956 _dl_start+0x26 (ld-2.19.so) -> ffffffff86a012e0 page_fault ([kernel])
|
|
|
|
import sys
|
|
import weakref
|
|
import threading
|
|
import string
|
|
import cPickle
|
|
import re
|
|
import os
|
|
from PySide.QtCore import *
|
|
from PySide.QtGui import *
|
|
from PySide.QtSql import *
|
|
from decimal import *
|
|
from ctypes import *
|
|
from multiprocessing import Process, Array, Value, Event
|
|
|
|
# Data formatting helpers
|
|
|
|
def tohex(ip):
|
|
if ip < 0:
|
|
ip += 1 << 64
|
|
return "%x" % ip
|
|
|
|
def offstr(offset):
|
|
if offset:
|
|
return "+0x%x" % offset
|
|
return ""
|
|
|
|
def dsoname(name):
|
|
if name == "[kernel.kallsyms]":
|
|
return "[kernel]"
|
|
return name
|
|
|
|
# Percent to one decimal place
|
|
|
|
def PercentToOneDP(n, d):
|
|
if not d:
|
|
return "0.0"
|
|
x = (n * Decimal(100)) / d
|
|
return str(x.quantize(Decimal(".1"), rounding=ROUND_HALF_UP))
|
|
|
|
# Helper for queries that must not fail
|
|
|
|
def QueryExec(query, stmt):
|
|
ret = query.exec_(stmt)
|
|
if not ret:
|
|
raise Exception("Query failed: " + query.lastError().text())
|
|
|
|
# Background thread
|
|
|
|
class Thread(QThread):
|
|
|
|
done = Signal(object)
|
|
|
|
def __init__(self, task, param=None, parent=None):
|
|
super(Thread, self).__init__(parent)
|
|
self.task = task
|
|
self.param = param
|
|
|
|
def run(self):
|
|
while True:
|
|
if self.param is None:
|
|
done, result = self.task()
|
|
else:
|
|
done, result = self.task(self.param)
|
|
self.done.emit(result)
|
|
if done:
|
|
break
|
|
|
|
# Tree data model
|
|
|
|
class TreeModel(QAbstractItemModel):
|
|
|
|
def __init__(self, root, parent=None):
|
|
super(TreeModel, self).__init__(parent)
|
|
self.root = root
|
|
self.last_row_read = 0
|
|
|
|
def Item(self, parent):
|
|
if parent.isValid():
|
|
return parent.internalPointer()
|
|
else:
|
|
return self.root
|
|
|
|
def rowCount(self, parent):
|
|
result = self.Item(parent).childCount()
|
|
if result < 0:
|
|
result = 0
|
|
self.dataChanged.emit(parent, parent)
|
|
return result
|
|
|
|
def hasChildren(self, parent):
|
|
return self.Item(parent).hasChildren()
|
|
|
|
def headerData(self, section, orientation, role):
|
|
if role == Qt.TextAlignmentRole:
|
|
return self.columnAlignment(section)
|
|
if role != Qt.DisplayRole:
|
|
return None
|
|
if orientation != Qt.Horizontal:
|
|
return None
|
|
return self.columnHeader(section)
|
|
|
|
def parent(self, child):
|
|
child_item = child.internalPointer()
|
|
if child_item is self.root:
|
|
return QModelIndex()
|
|
parent_item = child_item.getParentItem()
|
|
return self.createIndex(parent_item.getRow(), 0, parent_item)
|
|
|
|
def index(self, row, column, parent):
|
|
child_item = self.Item(parent).getChildItem(row)
|
|
return self.createIndex(row, column, child_item)
|
|
|
|
def DisplayData(self, item, index):
|
|
return item.getData(index.column())
|
|
|
|
def FetchIfNeeded(self, row):
|
|
if row > self.last_row_read:
|
|
self.last_row_read = row
|
|
if row + 10 >= self.root.child_count:
|
|
self.fetcher.Fetch(glb_chunk_sz)
|
|
|
|
def columnAlignment(self, column):
|
|
return Qt.AlignLeft
|
|
|
|
def columnFont(self, column):
|
|
return None
|
|
|
|
def data(self, index, role):
|
|
if role == Qt.TextAlignmentRole:
|
|
return self.columnAlignment(index.column())
|
|
if role == Qt.FontRole:
|
|
return self.columnFont(index.column())
|
|
if role != Qt.DisplayRole:
|
|
return None
|
|
item = index.internalPointer()
|
|
return self.DisplayData(item, index)
|
|
|
|
# Table data model
|
|
|
|
class TableModel(QAbstractTableModel):
|
|
|
|
def __init__(self, parent=None):
|
|
super(TableModel, self).__init__(parent)
|
|
self.child_count = 0
|
|
self.child_items = []
|
|
self.last_row_read = 0
|
|
|
|
def Item(self, parent):
|
|
if parent.isValid():
|
|
return parent.internalPointer()
|
|
else:
|
|
return self
|
|
|
|
def rowCount(self, parent):
|
|
return self.child_count
|
|
|
|
def headerData(self, section, orientation, role):
|
|
if role == Qt.TextAlignmentRole:
|
|
return self.columnAlignment(section)
|
|
if role != Qt.DisplayRole:
|
|
return None
|
|
if orientation != Qt.Horizontal:
|
|
return None
|
|
return self.columnHeader(section)
|
|
|
|
def index(self, row, column, parent):
|
|
return self.createIndex(row, column, self.child_items[row])
|
|
|
|
def DisplayData(self, item, index):
|
|
return item.getData(index.column())
|
|
|
|
def FetchIfNeeded(self, row):
|
|
if row > self.last_row_read:
|
|
self.last_row_read = row
|
|
if row + 10 >= self.child_count:
|
|
self.fetcher.Fetch(glb_chunk_sz)
|
|
|
|
def columnAlignment(self, column):
|
|
return Qt.AlignLeft
|
|
|
|
def columnFont(self, column):
|
|
return None
|
|
|
|
def data(self, index, role):
|
|
if role == Qt.TextAlignmentRole:
|
|
return self.columnAlignment(index.column())
|
|
if role == Qt.FontRole:
|
|
return self.columnFont(index.column())
|
|
if role != Qt.DisplayRole:
|
|
return None
|
|
item = index.internalPointer()
|
|
return self.DisplayData(item, index)
|
|
|
|
# Model cache
|
|
|
|
model_cache = weakref.WeakValueDictionary()
|
|
model_cache_lock = threading.Lock()
|
|
|
|
def LookupCreateModel(model_name, create_fn):
|
|
model_cache_lock.acquire()
|
|
try:
|
|
model = model_cache[model_name]
|
|
except:
|
|
model = None
|
|
if model is None:
|
|
model = create_fn()
|
|
model_cache[model_name] = model
|
|
model_cache_lock.release()
|
|
return model
|
|
|
|
# Find bar
|
|
|
|
class FindBar():
|
|
|
|
def __init__(self, parent, finder, is_reg_expr=False):
|
|
self.finder = finder
|
|
self.context = []
|
|
self.last_value = None
|
|
self.last_pattern = None
|
|
|
|
label = QLabel("Find:")
|
|
label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
|
|
|
|
self.textbox = QComboBox()
|
|
self.textbox.setEditable(True)
|
|
self.textbox.currentIndexChanged.connect(self.ValueChanged)
|
|
|
|
self.progress = QProgressBar()
|
|
self.progress.setRange(0, 0)
|
|
self.progress.hide()
|
|
|
|
if is_reg_expr:
|
|
self.pattern = QCheckBox("Regular Expression")
|
|
else:
|
|
self.pattern = QCheckBox("Pattern")
|
|
self.pattern.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
|
|
|
|
self.next_button = QToolButton()
|
|
self.next_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowDown))
|
|
self.next_button.released.connect(lambda: self.NextPrev(1))
|
|
|
|
self.prev_button = QToolButton()
|
|
self.prev_button.setIcon(parent.style().standardIcon(QStyle.SP_ArrowUp))
|
|
self.prev_button.released.connect(lambda: self.NextPrev(-1))
|
|
|
|
self.close_button = QToolButton()
|
|
self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
|
|
self.close_button.released.connect(self.Deactivate)
|
|
|
|
self.hbox = QHBoxLayout()
|
|
self.hbox.setContentsMargins(0, 0, 0, 0)
|
|
|
|
self.hbox.addWidget(label)
|
|
self.hbox.addWidget(self.textbox)
|
|
self.hbox.addWidget(self.progress)
|
|
self.hbox.addWidget(self.pattern)
|
|
self.hbox.addWidget(self.next_button)
|
|
self.hbox.addWidget(self.prev_button)
|
|
self.hbox.addWidget(self.close_button)
|
|
|
|
self.bar = QWidget()
|
|
self.bar.setLayout(self.hbox);
|
|
self.bar.hide()
|
|
|
|
def Widget(self):
|
|
return self.bar
|
|
|
|
def Activate(self):
|
|
self.bar.show()
|
|
self.textbox.setFocus()
|
|
|
|
def Deactivate(self):
|
|
self.bar.hide()
|
|
|
|
def Busy(self):
|
|
self.textbox.setEnabled(False)
|
|
self.pattern.hide()
|
|
self.next_button.hide()
|
|
self.prev_button.hide()
|
|
self.progress.show()
|
|
|
|
def Idle(self):
|
|
self.textbox.setEnabled(True)
|
|
self.progress.hide()
|
|
self.pattern.show()
|
|
self.next_button.show()
|
|
self.prev_button.show()
|
|
|
|
def Find(self, direction):
|
|
value = self.textbox.currentText()
|
|
pattern = self.pattern.isChecked()
|
|
self.last_value = value
|
|
self.last_pattern = pattern
|
|
self.finder.Find(value, direction, pattern, self.context)
|
|
|
|
def ValueChanged(self):
|
|
value = self.textbox.currentText()
|
|
pattern = self.pattern.isChecked()
|
|
index = self.textbox.currentIndex()
|
|
data = self.textbox.itemData(index)
|
|
# Store the pattern in the combo box to keep it with the text value
|
|
if data == None:
|
|
self.textbox.setItemData(index, pattern)
|
|
else:
|
|
self.pattern.setChecked(data)
|
|
self.Find(0)
|
|
|
|
def NextPrev(self, direction):
|
|
value = self.textbox.currentText()
|
|
pattern = self.pattern.isChecked()
|
|
if value != self.last_value:
|
|
index = self.textbox.findText(value)
|
|
# Allow for a button press before the value has been added to the combo box
|
|
if index < 0:
|
|
index = self.textbox.count()
|
|
self.textbox.addItem(value, pattern)
|
|
self.textbox.setCurrentIndex(index)
|
|
return
|
|
else:
|
|
self.textbox.setItemData(index, pattern)
|
|
elif pattern != self.last_pattern:
|
|
# Keep the pattern recorded in the combo box up to date
|
|
index = self.textbox.currentIndex()
|
|
self.textbox.setItemData(index, pattern)
|
|
self.Find(direction)
|
|
|
|
def NotFound(self):
|
|
QMessageBox.information(self.bar, "Find", "'" + self.textbox.currentText() + "' not found")
|
|
|
|
# Context-sensitive call graph data model item base
|
|
|
|
class CallGraphLevelItemBase(object):
|
|
|
|
def __init__(self, glb, row, parent_item):
|
|
self.glb = glb
|
|
self.row = row
|
|
self.parent_item = parent_item
|
|
self.query_done = False;
|
|
self.child_count = 0
|
|
self.child_items = []
|
|
|
|
def getChildItem(self, row):
|
|
return self.child_items[row]
|
|
|
|
def getParentItem(self):
|
|
return self.parent_item
|
|
|
|
def getRow(self):
|
|
return self.row
|
|
|
|
def childCount(self):
|
|
if not self.query_done:
|
|
self.Select()
|
|
if not self.child_count:
|
|
return -1
|
|
return self.child_count
|
|
|
|
def hasChildren(self):
|
|
if not self.query_done:
|
|
return True
|
|
return self.child_count > 0
|
|
|
|
def getData(self, column):
|
|
return self.data[column]
|
|
|
|
# Context-sensitive call graph data model level 2+ item base
|
|
|
|
class CallGraphLevelTwoPlusItemBase(CallGraphLevelItemBase):
|
|
|
|
def __init__(self, glb, row, comm_id, thread_id, call_path_id, time, branch_count, parent_item):
|
|
super(CallGraphLevelTwoPlusItemBase, self).__init__(glb, row, parent_item)
|
|
self.comm_id = comm_id
|
|
self.thread_id = thread_id
|
|
self.call_path_id = call_path_id
|
|
self.branch_count = branch_count
|
|
self.time = time
|
|
|
|
def Select(self):
|
|
self.query_done = True;
|
|
query = QSqlQuery(self.glb.db)
|
|
QueryExec(query, "SELECT call_path_id, name, short_name, COUNT(calls.id), SUM(return_time - call_time), SUM(branch_count)"
|
|
" FROM calls"
|
|
" INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
|
|
" INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
|
|
" INNER JOIN dsos ON symbols.dso_id = dsos.id"
|
|
" WHERE parent_call_path_id = " + str(self.call_path_id) +
|
|
" AND comm_id = " + str(self.comm_id) +
|
|
" AND thread_id = " + str(self.thread_id) +
|
|
" GROUP BY call_path_id, name, short_name"
|
|
" ORDER BY call_path_id")
|
|
while query.next():
|
|
child_item = CallGraphLevelThreeItem(self.glb, self.child_count, self.comm_id, self.thread_id, query.value(0), query.value(1), query.value(2), query.value(3), int(query.value(4)), int(query.value(5)), self)
|
|
self.child_items.append(child_item)
|
|
self.child_count += 1
|
|
|
|
# Context-sensitive call graph data model level three item
|
|
|
|
class CallGraphLevelThreeItem(CallGraphLevelTwoPlusItemBase):
|
|
|
|
def __init__(self, glb, row, comm_id, thread_id, call_path_id, name, dso, count, time, branch_count, parent_item):
|
|
super(CallGraphLevelThreeItem, self).__init__(glb, row, comm_id, thread_id, call_path_id, time, branch_count, parent_item)
|
|
dso = dsoname(dso)
|
|
self.data = [ name, dso, str(count), str(time), PercentToOneDP(time, parent_item.time), str(branch_count), PercentToOneDP(branch_count, parent_item.branch_count) ]
|
|
self.dbid = call_path_id
|
|
|
|
# Context-sensitive call graph data model level two item
|
|
|
|
class CallGraphLevelTwoItem(CallGraphLevelTwoPlusItemBase):
|
|
|
|
def __init__(self, glb, row, comm_id, thread_id, pid, tid, parent_item):
|
|
super(CallGraphLevelTwoItem, self).__init__(glb, row, comm_id, thread_id, 1, 0, 0, parent_item)
|
|
self.data = [str(pid) + ":" + str(tid), "", "", "", "", "", ""]
|
|
self.dbid = thread_id
|
|
|
|
def Select(self):
|
|
super(CallGraphLevelTwoItem, self).Select()
|
|
for child_item in self.child_items:
|
|
self.time += child_item.time
|
|
self.branch_count += child_item.branch_count
|
|
for child_item in self.child_items:
|
|
child_item.data[4] = PercentToOneDP(child_item.time, self.time)
|
|
child_item.data[6] = PercentToOneDP(child_item.branch_count, self.branch_count)
|
|
|
|
# Context-sensitive call graph data model level one item
|
|
|
|
class CallGraphLevelOneItem(CallGraphLevelItemBase):
|
|
|
|
def __init__(self, glb, row, comm_id, comm, parent_item):
|
|
super(CallGraphLevelOneItem, self).__init__(glb, row, parent_item)
|
|
self.data = [comm, "", "", "", "", "", ""]
|
|
self.dbid = comm_id
|
|
|
|
def Select(self):
|
|
self.query_done = True;
|
|
query = QSqlQuery(self.glb.db)
|
|
QueryExec(query, "SELECT thread_id, pid, tid"
|
|
" FROM comm_threads"
|
|
" INNER JOIN threads ON thread_id = threads.id"
|
|
" WHERE comm_id = " + str(self.dbid))
|
|
while query.next():
|
|
child_item = CallGraphLevelTwoItem(self.glb, self.child_count, self.dbid, query.value(0), query.value(1), query.value(2), self)
|
|
self.child_items.append(child_item)
|
|
self.child_count += 1
|
|
|
|
# Context-sensitive call graph data model root item
|
|
|
|
class CallGraphRootItem(CallGraphLevelItemBase):
|
|
|
|
def __init__(self, glb):
|
|
super(CallGraphRootItem, self).__init__(glb, 0, None)
|
|
self.dbid = 0
|
|
self.query_done = True;
|
|
query = QSqlQuery(glb.db)
|
|
QueryExec(query, "SELECT id, comm FROM comms")
|
|
while query.next():
|
|
if not query.value(0):
|
|
continue
|
|
child_item = CallGraphLevelOneItem(glb, self.child_count, query.value(0), query.value(1), self)
|
|
self.child_items.append(child_item)
|
|
self.child_count += 1
|
|
|
|
# Context-sensitive call graph data model
|
|
|
|
class CallGraphModel(TreeModel):
|
|
|
|
def __init__(self, glb, parent=None):
|
|
super(CallGraphModel, self).__init__(CallGraphRootItem(glb), parent)
|
|
self.glb = glb
|
|
|
|
def columnCount(self, parent=None):
|
|
return 7
|
|
|
|
def columnHeader(self, column):
|
|
headers = ["Call Path", "Object", "Count ", "Time (ns) ", "Time (%) ", "Branch Count ", "Branch Count (%) "]
|
|
return headers[column]
|
|
|
|
def columnAlignment(self, column):
|
|
alignment = [ Qt.AlignLeft, Qt.AlignLeft, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight, Qt.AlignRight ]
|
|
return alignment[column]
|
|
|
|
def FindSelect(self, value, pattern, query):
|
|
if pattern:
|
|
# postgresql and sqlite pattern patching differences:
|
|
# postgresql LIKE is case sensitive but sqlite LIKE is not
|
|
# postgresql LIKE allows % and _ to be escaped with \ but sqlite LIKE does not
|
|
# postgresql supports ILIKE which is case insensitive
|
|
# sqlite supports GLOB (text only) which uses * and ? and is case sensitive
|
|
if not self.glb.dbref.is_sqlite3:
|
|
# Escape % and _
|
|
s = value.replace("%", "\%")
|
|
s = s.replace("_", "\_")
|
|
# Translate * and ? into SQL LIKE pattern characters % and _
|
|
trans = string.maketrans("*?", "%_")
|
|
match = " LIKE '" + str(s).translate(trans) + "'"
|
|
else:
|
|
match = " GLOB '" + str(value) + "'"
|
|
else:
|
|
match = " = '" + str(value) + "'"
|
|
QueryExec(query, "SELECT call_path_id, comm_id, thread_id"
|
|
" FROM calls"
|
|
" INNER JOIN call_paths ON calls.call_path_id = call_paths.id"
|
|
" INNER JOIN symbols ON call_paths.symbol_id = symbols.id"
|
|
" WHERE symbols.name" + match +
|
|
" GROUP BY comm_id, thread_id, call_path_id"
|
|
" ORDER BY comm_id, thread_id, call_path_id")
|
|
|
|
def FindPath(self, query):
|
|
# Turn the query result into a list of ids that the tree view can walk
|
|
# to open the tree at the right place.
|
|
ids = []
|
|
parent_id = query.value(0)
|
|
while parent_id:
|
|
ids.insert(0, parent_id)
|
|
q2 = QSqlQuery(self.glb.db)
|
|
QueryExec(q2, "SELECT parent_id"
|
|
" FROM call_paths"
|
|
" WHERE id = " + str(parent_id))
|
|
if not q2.next():
|
|
break
|
|
parent_id = q2.value(0)
|
|
# The call path root is not used
|
|
if ids[0] == 1:
|
|
del ids[0]
|
|
ids.insert(0, query.value(2))
|
|
ids.insert(0, query.value(1))
|
|
return ids
|
|
|
|
def Found(self, query, found):
|
|
if found:
|
|
return self.FindPath(query)
|
|
return []
|
|
|
|
def FindValue(self, value, pattern, query, last_value, last_pattern):
|
|
if last_value == value and pattern == last_pattern:
|
|
found = query.first()
|
|
else:
|
|
self.FindSelect(value, pattern, query)
|
|
found = query.next()
|
|
return self.Found(query, found)
|
|
|
|
def FindNext(self, query):
|
|
found = query.next()
|
|
if not found:
|
|
found = query.first()
|
|
return self.Found(query, found)
|
|
|
|
def FindPrev(self, query):
|
|
found = query.previous()
|
|
if not found:
|
|
found = query.last()
|
|
return self.Found(query, found)
|
|
|
|
def FindThread(self, c):
|
|
if c.direction == 0 or c.value != c.last_value or c.pattern != c.last_pattern:
|
|
ids = self.FindValue(c.value, c.pattern, c.query, c.last_value, c.last_pattern)
|
|
elif c.direction > 0:
|
|
ids = self.FindNext(c.query)
|
|
else:
|
|
ids = self.FindPrev(c.query)
|
|
return (True, ids)
|
|
|
|
def Find(self, value, direction, pattern, context, callback):
|
|
class Context():
|
|
def __init__(self, *x):
|
|
self.value, self.direction, self.pattern, self.query, self.last_value, self.last_pattern = x
|
|
def Update(self, *x):
|
|
self.value, self.direction, self.pattern, self.last_value, self.last_pattern = x + (self.value, self.pattern)
|
|
if len(context):
|
|
context[0].Update(value, direction, pattern)
|
|
else:
|
|
context.append(Context(value, direction, pattern, QSqlQuery(self.glb.db), None, None))
|
|
# Use a thread so the UI is not blocked during the SELECT
|
|
thread = Thread(self.FindThread, context[0])
|
|
thread.done.connect(lambda ids, t=thread, c=callback: self.FindDone(t, c, ids), Qt.QueuedConnection)
|
|
thread.start()
|
|
|
|
def FindDone(self, thread, callback, ids):
|
|
callback(ids)
|
|
|
|
# Vertical widget layout
|
|
|
|
class VBox():
|
|
|
|
def __init__(self, w1, w2, w3=None):
|
|
self.vbox = QWidget()
|
|
self.vbox.setLayout(QVBoxLayout());
|
|
|
|
self.vbox.layout().setContentsMargins(0, 0, 0, 0)
|
|
|
|
self.vbox.layout().addWidget(w1)
|
|
self.vbox.layout().addWidget(w2)
|
|
if w3:
|
|
self.vbox.layout().addWidget(w3)
|
|
|
|
def Widget(self):
|
|
return self.vbox
|
|
|
|
# Context-sensitive call graph window
|
|
|
|
class CallGraphWindow(QMdiSubWindow):
|
|
|
|
def __init__(self, glb, parent=None):
|
|
super(CallGraphWindow, self).__init__(parent)
|
|
|
|
self.model = LookupCreateModel("Context-Sensitive Call Graph", lambda x=glb: CallGraphModel(x))
|
|
|
|
self.view = QTreeView()
|
|
self.view.setModel(self.model)
|
|
|
|
for c, w in ((0, 250), (1, 100), (2, 60), (3, 70), (4, 70), (5, 100)):
|
|
self.view.setColumnWidth(c, w)
|
|
|
|
self.find_bar = FindBar(self, self)
|
|
|
|
self.vbox = VBox(self.view, self.find_bar.Widget())
|
|
|
|
self.setWidget(self.vbox.Widget())
|
|
|
|
AddSubWindow(glb.mainwindow.mdi_area, self, "Context-Sensitive Call Graph")
|
|
|
|
def DisplayFound(self, ids):
|
|
if not len(ids):
|
|
return False
|
|
parent = QModelIndex()
|
|
for dbid in ids:
|
|
found = False
|
|
n = self.model.rowCount(parent)
|
|
for row in xrange(n):
|
|
child = self.model.index(row, 0, parent)
|
|
if child.internalPointer().dbid == dbid:
|
|
found = True
|
|
self.view.setCurrentIndex(child)
|
|
parent = child
|
|
break
|
|
if not found:
|
|
break
|
|
return found
|
|
|
|
def Find(self, value, direction, pattern, context):
|
|
self.view.setFocus()
|
|
self.find_bar.Busy()
|
|
self.model.Find(value, direction, pattern, context, self.FindDone)
|
|
|
|
def FindDone(self, ids):
|
|
found = True
|
|
if not self.DisplayFound(ids):
|
|
found = False
|
|
self.find_bar.Idle()
|
|
if not found:
|
|
self.find_bar.NotFound()
|
|
|
|
# Child data item finder
|
|
|
|
class ChildDataItemFinder():
|
|
|
|
def __init__(self, root):
|
|
self.root = root
|
|
self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (None,) * 5
|
|
self.rows = []
|
|
self.pos = 0
|
|
|
|
def FindSelect(self):
|
|
self.rows = []
|
|
if self.pattern:
|
|
pattern = re.compile(self.value)
|
|
for child in self.root.child_items:
|
|
for column_data in child.data:
|
|
if re.search(pattern, str(column_data)) is not None:
|
|
self.rows.append(child.row)
|
|
break
|
|
else:
|
|
for child in self.root.child_items:
|
|
for column_data in child.data:
|
|
if self.value in str(column_data):
|
|
self.rows.append(child.row)
|
|
break
|
|
|
|
def FindValue(self):
|
|
self.pos = 0
|
|
if self.last_value != self.value or self.pattern != self.last_pattern:
|
|
self.FindSelect()
|
|
if not len(self.rows):
|
|
return -1
|
|
return self.rows[self.pos]
|
|
|
|
def FindThread(self):
|
|
if self.direction == 0 or self.value != self.last_value or self.pattern != self.last_pattern:
|
|
row = self.FindValue()
|
|
elif len(self.rows):
|
|
if self.direction > 0:
|
|
self.pos += 1
|
|
if self.pos >= len(self.rows):
|
|
self.pos = 0
|
|
else:
|
|
self.pos -= 1
|
|
if self.pos < 0:
|
|
self.pos = len(self.rows) - 1
|
|
row = self.rows[self.pos]
|
|
else:
|
|
row = -1
|
|
return (True, row)
|
|
|
|
def Find(self, value, direction, pattern, context, callback):
|
|
self.value, self.direction, self.pattern, self.last_value, self.last_pattern = (value, direction,pattern, self.value, self.pattern)
|
|
# Use a thread so the UI is not blocked
|
|
thread = Thread(self.FindThread)
|
|
thread.done.connect(lambda row, t=thread, c=callback: self.FindDone(t, c, row), Qt.QueuedConnection)
|
|
thread.start()
|
|
|
|
def FindDone(self, thread, callback, row):
|
|
callback(row)
|
|
|
|
# Number of database records to fetch in one go
|
|
|
|
glb_chunk_sz = 10000
|
|
|
|
# size of pickled integer big enough for record size
|
|
|
|
glb_nsz = 8
|
|
|
|
# Background process for SQL data fetcher
|
|
|
|
class SQLFetcherProcess():
|
|
|
|
def __init__(self, dbref, sql, buffer, head, tail, fetch_count, fetching_done, process_target, wait_event, fetched_event, prep):
|
|
# Need a unique connection name
|
|
conn_name = "SQLFetcher" + str(os.getpid())
|
|
self.db, dbname = dbref.Open(conn_name)
|
|
self.sql = sql
|
|
self.buffer = buffer
|
|
self.head = head
|
|
self.tail = tail
|
|
self.fetch_count = fetch_count
|
|
self.fetching_done = fetching_done
|
|
self.process_target = process_target
|
|
self.wait_event = wait_event
|
|
self.fetched_event = fetched_event
|
|
self.prep = prep
|
|
self.query = QSqlQuery(self.db)
|
|
self.query_limit = 0 if "$$last_id$$" in sql else 2
|
|
self.last_id = -1
|
|
self.fetched = 0
|
|
self.more = True
|
|
self.local_head = self.head.value
|
|
self.local_tail = self.tail.value
|
|
|
|
def Select(self):
|
|
if self.query_limit:
|
|
if self.query_limit == 1:
|
|
return
|
|
self.query_limit -= 1
|
|
stmt = self.sql.replace("$$last_id$$", str(self.last_id))
|
|
QueryExec(self.query, stmt)
|
|
|
|
def Next(self):
|
|
if not self.query.next():
|
|
self.Select()
|
|
if not self.query.next():
|
|
return None
|
|
self.last_id = self.query.value(0)
|
|
return self.prep(self.query)
|
|
|
|
def WaitForTarget(self):
|
|
while True:
|
|
self.wait_event.clear()
|
|
target = self.process_target.value
|
|
if target > self.fetched or target < 0:
|
|
break
|
|
self.wait_event.wait()
|
|
return target
|
|
|
|
def HasSpace(self, sz):
|
|
if self.local_tail <= self.local_head:
|
|
space = len(self.buffer) - self.local_head
|
|
if space > sz:
|
|
return True
|
|
if space >= glb_nsz:
|
|
# Use 0 (or space < glb_nsz) to mean there is no more at the top of the buffer
|
|
nd = cPickle.dumps(0, cPickle.HIGHEST_PROTOCOL)
|
|
self.buffer[self.local_head : self.local_head + len(nd)] = nd
|
|
self.local_head = 0
|
|
if self.local_tail - self.local_head > sz:
|
|
return True
|
|
return False
|
|
|
|
def WaitForSpace(self, sz):
|
|
if self.HasSpace(sz):
|
|
return
|
|
while True:
|
|
self.wait_event.clear()
|
|
self.local_tail = self.tail.value
|
|
if self.HasSpace(sz):
|
|
return
|
|
self.wait_event.wait()
|
|
|
|
def AddToBuffer(self, obj):
|
|
d = cPickle.dumps(obj, cPickle.HIGHEST_PROTOCOL)
|
|
n = len(d)
|
|
nd = cPickle.dumps(n, cPickle.HIGHEST_PROTOCOL)
|
|
sz = n + glb_nsz
|
|
self.WaitForSpace(sz)
|
|
pos = self.local_head
|
|
self.buffer[pos : pos + len(nd)] = nd
|
|
self.buffer[pos + glb_nsz : pos + sz] = d
|
|
self.local_head += sz
|
|
|
|
def FetchBatch(self, batch_size):
|
|
fetched = 0
|
|
while batch_size > fetched:
|
|
obj = self.Next()
|
|
if obj is None:
|
|
self.more = False
|
|
break
|
|
self.AddToBuffer(obj)
|
|
fetched += 1
|
|
if fetched:
|
|
self.fetched += fetched
|
|
with self.fetch_count.get_lock():
|
|
self.fetch_count.value += fetched
|
|
self.head.value = self.local_head
|
|
self.fetched_event.set()
|
|
|
|
def Run(self):
|
|
while self.more:
|
|
target = self.WaitForTarget()
|
|
if target < 0:
|
|
break
|
|
batch_size = min(glb_chunk_sz, target - self.fetched)
|
|
self.FetchBatch(batch_size)
|
|
self.fetching_done.value = True
|
|
self.fetched_event.set()
|
|
|
|
def SQLFetcherFn(*x):
|
|
process = SQLFetcherProcess(*x)
|
|
process.Run()
|
|
|
|
# SQL data fetcher
|
|
|
|
class SQLFetcher(QObject):
|
|
|
|
done = Signal(object)
|
|
|
|
def __init__(self, glb, sql, prep, process_data, parent=None):
|
|
super(SQLFetcher, self).__init__(parent)
|
|
self.process_data = process_data
|
|
self.more = True
|
|
self.target = 0
|
|
self.last_target = 0
|
|
self.fetched = 0
|
|
self.buffer_size = 16 * 1024 * 1024
|
|
self.buffer = Array(c_char, self.buffer_size, lock=False)
|
|
self.head = Value(c_longlong)
|
|
self.tail = Value(c_longlong)
|
|
self.local_tail = 0
|
|
self.fetch_count = Value(c_longlong)
|
|
self.fetching_done = Value(c_bool)
|
|
self.last_count = 0
|
|
self.process_target = Value(c_longlong)
|
|
self.wait_event = Event()
|
|
self.fetched_event = Event()
|
|
glb.AddInstanceToShutdownOnExit(self)
|
|
self.process = Process(target=SQLFetcherFn, args=(glb.dbref, sql, self.buffer, self.head, self.tail, self.fetch_count, self.fetching_done, self.process_target, self.wait_event, self.fetched_event, prep))
|
|
self.process.start()
|
|
self.thread = Thread(self.Thread)
|
|
self.thread.done.connect(self.ProcessData, Qt.QueuedConnection)
|
|
self.thread.start()
|
|
|
|
def Shutdown(self):
|
|
# Tell the thread and process to exit
|
|
self.process_target.value = -1
|
|
self.wait_event.set()
|
|
self.more = False
|
|
self.fetching_done.value = True
|
|
self.fetched_event.set()
|
|
|
|
def Thread(self):
|
|
if not self.more:
|
|
return True, 0
|
|
while True:
|
|
self.fetched_event.clear()
|
|
fetch_count = self.fetch_count.value
|
|
if fetch_count != self.last_count:
|
|
break
|
|
if self.fetching_done.value:
|
|
self.more = False
|
|
return True, 0
|
|
self.fetched_event.wait()
|
|
count = fetch_count - self.last_count
|
|
self.last_count = fetch_count
|
|
self.fetched += count
|
|
return False, count
|
|
|
|
def Fetch(self, nr):
|
|
if not self.more:
|
|
# -1 inidcates there are no more
|
|
return -1
|
|
result = self.fetched
|
|
extra = result + nr - self.target
|
|
if extra > 0:
|
|
self.target += extra
|
|
# process_target < 0 indicates shutting down
|
|
if self.process_target.value >= 0:
|
|
self.process_target.value = self.target
|
|
self.wait_event.set()
|
|
return result
|
|
|
|
def RemoveFromBuffer(self):
|
|
pos = self.local_tail
|
|
if len(self.buffer) - pos < glb_nsz:
|
|
pos = 0
|
|
n = cPickle.loads(self.buffer[pos : pos + glb_nsz])
|
|
if n == 0:
|
|
pos = 0
|
|
n = cPickle.loads(self.buffer[0 : glb_nsz])
|
|
pos += glb_nsz
|
|
obj = cPickle.loads(self.buffer[pos : pos + n])
|
|
self.local_tail = pos + n
|
|
return obj
|
|
|
|
def ProcessData(self, count):
|
|
for i in xrange(count):
|
|
obj = self.RemoveFromBuffer()
|
|
self.process_data(obj)
|
|
self.tail.value = self.local_tail
|
|
self.wait_event.set()
|
|
self.done.emit(count)
|
|
|
|
# Fetch more records bar
|
|
|
|
class FetchMoreRecordsBar():
|
|
|
|
def __init__(self, model, parent):
|
|
self.model = model
|
|
|
|
self.label = QLabel("Number of records (x " + "{:,}".format(glb_chunk_sz) + ") to fetch:")
|
|
self.label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
|
|
|
|
self.fetch_count = QSpinBox()
|
|
self.fetch_count.setRange(1, 1000000)
|
|
self.fetch_count.setValue(10)
|
|
self.fetch_count.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
|
|
|
|
self.fetch = QPushButton("Go!")
|
|
self.fetch.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
|
|
self.fetch.released.connect(self.FetchMoreRecords)
|
|
|
|
self.progress = QProgressBar()
|
|
self.progress.setRange(0, 100)
|
|
self.progress.hide()
|
|
|
|
self.done_label = QLabel("All records fetched")
|
|
self.done_label.hide()
|
|
|
|
self.spacer = QLabel("")
|
|
|
|
self.close_button = QToolButton()
|
|
self.close_button.setIcon(parent.style().standardIcon(QStyle.SP_DockWidgetCloseButton))
|
|
self.close_button.released.connect(self.Deactivate)
|
|
|
|
self.hbox = QHBoxLayout()
|
|
self.hbox.setContentsMargins(0, 0, 0, 0)
|
|
|
|
self.hbox.addWidget(self.label)
|
|
self.hbox.addWidget(self.fetch_count)
|
|
self.hbox.addWidget(self.fetch)
|
|
self.hbox.addWidget(self.spacer)
|
|
self.hbox.addWidget(self.progress)
|
|
self.hbox.addWidget(self.done_label)
|
|
self.hbox.addWidget(self.close_button)
|
|
|
|
self.bar = QWidget()
|
|
self.bar.setLayout(self.hbox);
|
|
self.bar.show()
|
|
|
|
self.in_progress = False
|
|
self.model.progress.connect(self.Progress)
|
|
|
|
self.done = False
|
|
|
|
if not model.HasMoreRecords():
|
|
self.Done()
|
|
|
|
def Widget(self):
|
|
return self.bar
|
|
|
|
def Activate(self):
|
|
self.bar.show()
|
|
self.fetch.setFocus()
|
|
|
|
def Deactivate(self):
|
|
self.bar.hide()
|
|
|
|
def Enable(self, enable):
|
|
self.fetch.setEnabled(enable)
|
|
self.fetch_count.setEnabled(enable)
|
|
|
|
def Busy(self):
|
|
self.Enable(False)
|
|
self.fetch.hide()
|
|
self.spacer.hide()
|
|
self.progress.show()
|
|
|
|
def Idle(self):
|
|
self.in_progress = False
|
|
self.Enable(True)
|
|
self.progress.hide()
|
|
self.fetch.show()
|
|
self.spacer.show()
|
|
|
|
def Target(self):
|
|
return self.fetch_count.value() * glb_chunk_sz
|
|
|
|
def Done(self):
|
|
self.done = True
|
|
self.Idle()
|
|
self.label.hide()
|
|
self.fetch_count.hide()
|
|
self.fetch.hide()
|
|
self.spacer.hide()
|
|
self.done_label.show()
|
|
|
|
def Progress(self, count):
|
|
if self.in_progress:
|
|
if count:
|
|
percent = ((count - self.start) * 100) / self.Target()
|
|
if percent >= 100:
|
|
self.Idle()
|
|
else:
|
|
self.progress.setValue(percent)
|
|
if not count:
|
|
# Count value of zero means no more records
|
|
self.Done()
|
|
|
|
def FetchMoreRecords(self):
|
|
if self.done:
|
|
return
|
|
self.progress.setValue(0)
|
|
self.Busy()
|
|
self.in_progress = True
|
|
self.start = self.model.FetchMoreRecords(self.Target())
|
|
|
|
# Brance data model level two item
|
|
|
|
class BranchLevelTwoItem():
|
|
|
|
def __init__(self, row, text, parent_item):
|
|
self.row = row
|
|
self.parent_item = parent_item
|
|
self.data = [""] * 8
|
|
self.data[7] = text
|
|
self.level = 2
|
|
|
|
def getParentItem(self):
|
|
return self.parent_item
|
|
|
|
def getRow(self):
|
|
return self.row
|
|
|
|
def childCount(self):
|
|
return 0
|
|
|
|
def hasChildren(self):
|
|
return False
|
|
|
|
def getData(self, column):
|
|
return self.data[column]
|
|
|
|
# Brance data model level one item
|
|
|
|
class BranchLevelOneItem():
|
|
|
|
def __init__(self, glb, row, data, parent_item):
|
|
self.glb = glb
|
|
self.row = row
|
|
self.parent_item = parent_item
|
|
self.child_count = 0
|
|
self.child_items = []
|
|
self.data = data[1:]
|
|
self.dbid = data[0]
|
|
self.level = 1
|
|
self.query_done = False
|
|
|
|
def getChildItem(self, row):
|
|
return self.child_items[row]
|
|
|
|
def getParentItem(self):
|
|
return self.parent_item
|
|
|
|
def getRow(self):
|
|
return self.row
|
|
|
|
def Select(self):
|
|
self.query_done = True
|
|
|
|
if not self.glb.have_disassembler:
|
|
return
|
|
|
|
query = QSqlQuery(self.glb.db)
|
|
|
|
QueryExec(query, "SELECT cpu, to_dso_id, to_symbol_id, to_sym_offset, short_name, long_name, build_id, sym_start, to_ip"
|
|
" FROM samples"
|
|
" INNER JOIN dsos ON samples.to_dso_id = dsos.id"
|
|
" INNER JOIN symbols ON samples.to_symbol_id = symbols.id"
|
|
" WHERE samples.id = " + str(self.dbid))
|
|
if not query.next():
|
|
return
|
|
cpu = query.value(0)
|
|
dso = query.value(1)
|
|
sym = query.value(2)
|
|
if dso == 0 or sym == 0:
|
|
return
|
|
off = query.value(3)
|
|
short_name = query.value(4)
|
|
long_name = query.value(5)
|
|
build_id = query.value(6)
|
|
sym_start = query.value(7)
|
|
ip = query.value(8)
|
|
|
|
QueryExec(query, "SELECT samples.dso_id, symbol_id, sym_offset, sym_start"
|
|
" FROM samples"
|
|
" INNER JOIN symbols ON samples.symbol_id = symbols.id"
|
|
" WHERE samples.id > " + str(self.dbid) + " AND cpu = " + str(cpu) +
|
|
" ORDER BY samples.id"
|
|
" LIMIT 1")
|
|
if not query.next():
|
|
return
|
|
if query.value(0) != dso:
|
|
# Cannot disassemble from one dso to another
|
|
return
|
|
bsym = query.value(1)
|
|
boff = query.value(2)
|
|
bsym_start = query.value(3)
|
|
if bsym == 0:
|
|
return
|
|
tot = bsym_start + boff + 1 - sym_start - off
|
|
if tot <= 0 or tot > 16384:
|
|
return
|
|
|
|
inst = self.glb.disassembler.Instruction()
|
|
f = self.glb.FileFromNamesAndBuildId(short_name, long_name, build_id)
|
|
if not f:
|
|
return
|
|
mode = 0 if Is64Bit(f) else 1
|
|
self.glb.disassembler.SetMode(inst, mode)
|
|
|
|
buf_sz = tot + 16
|
|
buf = create_string_buffer(tot + 16)
|
|
f.seek(sym_start + off)
|
|
buf.value = f.read(buf_sz)
|
|
buf_ptr = addressof(buf)
|
|
i = 0
|
|
while tot > 0:
|
|
cnt, text = self.glb.disassembler.DisassembleOne(inst, buf_ptr, buf_sz, ip)
|
|
if cnt:
|
|
byte_str = tohex(ip).rjust(16)
|
|
for k in xrange(cnt):
|
|
byte_str += " %02x" % ord(buf[i])
|
|
i += 1
|
|
while k < 15:
|
|
byte_str += " "
|
|
k += 1
|
|
self.child_items.append(BranchLevelTwoItem(0, byte_str + " " + text, self))
|
|
self.child_count += 1
|
|
else:
|
|
return
|
|
buf_ptr += cnt
|
|
tot -= cnt
|
|
buf_sz -= cnt
|
|
ip += cnt
|
|
|
|
def childCount(self):
|
|
if not self.query_done:
|
|
self.Select()
|
|
if not self.child_count:
|
|
return -1
|
|
return self.child_count
|
|
|
|
def hasChildren(self):
|
|
if not self.query_done:
|
|
return True
|
|
return self.child_count > 0
|
|
|
|
def getData(self, column):
|
|
return self.data[column]
|
|
|
|
# Brance data model root item
|
|
|
|
class BranchRootItem():
|
|
|
|
def __init__(self):
|
|
self.child_count = 0
|
|
self.child_items = []
|
|
self.level = 0
|
|
|
|
def getChildItem(self, row):
|
|
return self.child_items[row]
|
|
|
|
def getParentItem(self):
|
|
return None
|
|
|
|
def getRow(self):
|
|
return 0
|
|
|
|
def childCount(self):
|
|
return self.child_count
|
|
|
|
def hasChildren(self):
|
|
return self.child_count > 0
|
|
|
|
def getData(self, column):
|
|
return ""
|
|
|
|
# Branch data preparation
|
|
|
|
def BranchDataPrep(query):
|
|
data = []
|
|
for i in xrange(0, 8):
|
|
data.append(query.value(i))
|
|
data.append(tohex(query.value(8)).rjust(16) + " " + query.value(9) + offstr(query.value(10)) +
|
|
" (" + dsoname(query.value(11)) + ")" + " -> " +
|
|
tohex(query.value(12)) + " " + query.value(13) + offstr(query.value(14)) +
|
|
" (" + dsoname(query.value(15)) + ")")
|
|
return data
|
|
|
|
# Branch data model
|
|
|
|
class BranchModel(TreeModel):
|
|
|
|
progress = Signal(object)
|
|
|
|
def __init__(self, glb, event_id, where_clause, parent=None):
|
|
super(BranchModel, self).__init__(BranchRootItem(), parent)
|
|
self.glb = glb
|
|
self.event_id = event_id
|
|
self.more = True
|
|
self.populated = 0
|
|
sql = ("SELECT samples.id, time, cpu, comm, pid, tid, branch_types.name,"
|
|
" CASE WHEN in_tx = '0' THEN 'No' ELSE 'Yes' END,"
|
|
" ip, symbols.name, sym_offset, dsos.short_name,"
|
|
" to_ip, to_symbols.name, to_sym_offset, to_dsos.short_name"
|
|
" FROM samples"
|
|
" INNER JOIN comms ON comm_id = comms.id"
|
|
" INNER JOIN threads ON thread_id = threads.id"
|
|
" INNER JOIN branch_types ON branch_type = branch_types.id"
|
|
" INNER JOIN symbols ON symbol_id = symbols.id"
|
|
" INNER JOIN symbols to_symbols ON to_symbol_id = to_symbols.id"
|
|
" INNER JOIN dsos ON samples.dso_id = dsos.id"
|
|
" INNER JOIN dsos AS to_dsos ON samples.to_dso_id = to_dsos.id"
|
|
" WHERE samples.id > $$last_id$$" + where_clause +
|
|
" AND evsel_id = " + str(self.event_id) +
|
|
" ORDER BY samples.id"
|
|
" LIMIT " + str(glb_chunk_sz))
|
|
self.fetcher = SQLFetcher(glb, sql, BranchDataPrep, self.AddSample)
|
|
self.fetcher.done.connect(self.Update)
|
|
self.fetcher.Fetch(glb_chunk_sz)
|
|
|
|
def columnCount(self, parent=None):
|
|
return 8
|
|
|
|
def columnHeader(self, column):
|
|
return ("Time", "CPU", "Command", "PID", "TID", "Branch Type", "In Tx", "Branch")[column]
|
|
|
|
def columnFont(self, column):
|
|
if column != 7:
|
|
return None
|
|
return QFont("Monospace")
|
|
|
|
def DisplayData(self, item, index):
|
|
if item.level == 1:
|
|
self.FetchIfNeeded(item.row)
|
|
return item.getData(index.column())
|
|
|
|
def AddSample(self, data):
|
|
child = BranchLevelOneItem(self.glb, self.populated, data, self.root)
|
|
self.root.child_items.append(child)
|
|
self.populated += 1
|
|
|
|
def Update(self, fetched):
|
|
if not fetched:
|
|
self.more = False
|
|
self.progress.emit(0)
|
|
child_count = self.root.child_count
|
|
count = self.populated - child_count
|
|
if count > 0:
|
|
parent = QModelIndex()
|
|
self.beginInsertRows(parent, child_count, child_count + count - 1)
|
|
self.insertRows(child_count, count, parent)
|
|
self.root.child_count += count
|
|
self.endInsertRows()
|
|
self.progress.emit(self.root.child_count)
|
|
|
|
def FetchMoreRecords(self, count):
|
|
current = self.root.child_count
|
|
if self.more:
|
|
self.fetcher.Fetch(count)
|
|
else:
|
|
self.progress.emit(0)
|
|
return current
|
|
|
|
def HasMoreRecords(self):
|
|
return self.more
|
|
|
|
# Branch window
|
|
|
|
class BranchWindow(QMdiSubWindow):
|
|
|
|
def __init__(self, glb, event_id, name, where_clause, parent=None):
|
|
super(BranchWindow, self).__init__(parent)
|
|
|
|
model_name = "Branch Events " + str(event_id)
|
|
if len(where_clause):
|
|
model_name = where_clause + " " + model_name
|
|
|
|
self.model = LookupCreateModel(model_name, lambda: BranchModel(glb, event_id, where_clause))
|
|
|
|
self.view = QTreeView()
|
|
self.view.setUniformRowHeights(True)
|
|
self.view.setModel(self.model)
|
|
|
|
self.ResizeColumnsToContents()
|
|
|
|
self.find_bar = FindBar(self, self, True)
|
|
|
|
self.finder = ChildDataItemFinder(self.model.root)
|
|
|
|
self.fetch_bar = FetchMoreRecordsBar(self.model, self)
|
|
|
|
self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
|
|
|
|
self.setWidget(self.vbox.Widget())
|
|
|
|
AddSubWindow(glb.mainwindow.mdi_area, self, name + " Branch Events")
|
|
|
|
def ResizeColumnToContents(self, column, n):
|
|
# Using the view's resizeColumnToContents() here is extrememly slow
|
|
# so implement a crude alternative
|
|
mm = "MM" if column else "MMMM"
|
|
font = self.view.font()
|
|
metrics = QFontMetrics(font)
|
|
max = 0
|
|
for row in xrange(n):
|
|
val = self.model.root.child_items[row].data[column]
|
|
len = metrics.width(str(val) + mm)
|
|
max = len if len > max else max
|
|
val = self.model.columnHeader(column)
|
|
len = metrics.width(str(val) + mm)
|
|
max = len if len > max else max
|
|
self.view.setColumnWidth(column, max)
|
|
|
|
def ResizeColumnsToContents(self):
|
|
n = min(self.model.root.child_count, 100)
|
|
if n < 1:
|
|
# No data yet, so connect a signal to notify when there is
|
|
self.model.rowsInserted.connect(self.UpdateColumnWidths)
|
|
return
|
|
columns = self.model.columnCount()
|
|
for i in xrange(columns):
|
|
self.ResizeColumnToContents(i, n)
|
|
|
|
def UpdateColumnWidths(self, *x):
|
|
# This only needs to be done once, so disconnect the signal now
|
|
self.model.rowsInserted.disconnect(self.UpdateColumnWidths)
|
|
self.ResizeColumnsToContents()
|
|
|
|
def Find(self, value, direction, pattern, context):
|
|
self.view.setFocus()
|
|
self.find_bar.Busy()
|
|
self.finder.Find(value, direction, pattern, context, self.FindDone)
|
|
|
|
def FindDone(self, row):
|
|
self.find_bar.Idle()
|
|
if row >= 0:
|
|
self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
|
|
else:
|
|
self.find_bar.NotFound()
|
|
|
|
# Event list
|
|
|
|
def GetEventList(db):
|
|
events = []
|
|
query = QSqlQuery(db)
|
|
QueryExec(query, "SELECT name FROM selected_events WHERE id > 0 ORDER BY id")
|
|
while query.next():
|
|
events.append(query.value(0))
|
|
return events
|
|
|
|
# SQL data preparation
|
|
|
|
def SQLTableDataPrep(query, count):
|
|
data = []
|
|
for i in xrange(count):
|
|
data.append(query.value(i))
|
|
return data
|
|
|
|
# SQL table data model item
|
|
|
|
class SQLTableItem():
|
|
|
|
def __init__(self, row, data):
|
|
self.row = row
|
|
self.data = data
|
|
|
|
def getData(self, column):
|
|
return self.data[column]
|
|
|
|
# SQL table data model
|
|
|
|
class SQLTableModel(TableModel):
|
|
|
|
progress = Signal(object)
|
|
|
|
def __init__(self, glb, sql, column_count, parent=None):
|
|
super(SQLTableModel, self).__init__(parent)
|
|
self.glb = glb
|
|
self.more = True
|
|
self.populated = 0
|
|
self.fetcher = SQLFetcher(glb, sql, lambda x, y=column_count: SQLTableDataPrep(x, y), self.AddSample)
|
|
self.fetcher.done.connect(self.Update)
|
|
self.fetcher.Fetch(glb_chunk_sz)
|
|
|
|
def DisplayData(self, item, index):
|
|
self.FetchIfNeeded(item.row)
|
|
return item.getData(index.column())
|
|
|
|
def AddSample(self, data):
|
|
child = SQLTableItem(self.populated, data)
|
|
self.child_items.append(child)
|
|
self.populated += 1
|
|
|
|
def Update(self, fetched):
|
|
if not fetched:
|
|
self.more = False
|
|
self.progress.emit(0)
|
|
child_count = self.child_count
|
|
count = self.populated - child_count
|
|
if count > 0:
|
|
parent = QModelIndex()
|
|
self.beginInsertRows(parent, child_count, child_count + count - 1)
|
|
self.insertRows(child_count, count, parent)
|
|
self.child_count += count
|
|
self.endInsertRows()
|
|
self.progress.emit(self.child_count)
|
|
|
|
def FetchMoreRecords(self, count):
|
|
current = self.child_count
|
|
if self.more:
|
|
self.fetcher.Fetch(count)
|
|
else:
|
|
self.progress.emit(0)
|
|
return current
|
|
|
|
def HasMoreRecords(self):
|
|
return self.more
|
|
|
|
# SQL automatic table data model
|
|
|
|
class SQLAutoTableModel(SQLTableModel):
|
|
|
|
def __init__(self, glb, table_name, parent=None):
|
|
sql = "SELECT * FROM " + table_name + " WHERE id > $$last_id$$ ORDER BY id LIMIT " + str(glb_chunk_sz)
|
|
if table_name == "comm_threads_view":
|
|
# For now, comm_threads_view has no id column
|
|
sql = "SELECT * FROM " + table_name + " WHERE comm_id > $$last_id$$ ORDER BY comm_id LIMIT " + str(glb_chunk_sz)
|
|
self.column_headers = []
|
|
query = QSqlQuery(glb.db)
|
|
if glb.dbref.is_sqlite3:
|
|
QueryExec(query, "PRAGMA table_info(" + table_name + ")")
|
|
while query.next():
|
|
self.column_headers.append(query.value(1))
|
|
if table_name == "sqlite_master":
|
|
sql = "SELECT * FROM " + table_name
|
|
else:
|
|
if table_name[:19] == "information_schema.":
|
|
sql = "SELECT * FROM " + table_name
|
|
select_table_name = table_name[19:]
|
|
schema = "information_schema"
|
|
else:
|
|
select_table_name = table_name
|
|
schema = "public"
|
|
QueryExec(query, "SELECT column_name FROM information_schema.columns WHERE table_schema = '" + schema + "' and table_name = '" + select_table_name + "'")
|
|
while query.next():
|
|
self.column_headers.append(query.value(0))
|
|
super(SQLAutoTableModel, self).__init__(glb, sql, len(self.column_headers), parent)
|
|
|
|
def columnCount(self, parent=None):
|
|
return len(self.column_headers)
|
|
|
|
def columnHeader(self, column):
|
|
return self.column_headers[column]
|
|
|
|
# Base class for custom ResizeColumnsToContents
|
|
|
|
class ResizeColumnsToContentsBase(QObject):
|
|
|
|
def __init__(self, parent=None):
|
|
super(ResizeColumnsToContentsBase, self).__init__(parent)
|
|
|
|
def ResizeColumnToContents(self, column, n):
|
|
# Using the view's resizeColumnToContents() here is extrememly slow
|
|
# so implement a crude alternative
|
|
font = self.view.font()
|
|
metrics = QFontMetrics(font)
|
|
max = 0
|
|
for row in xrange(n):
|
|
val = self.data_model.child_items[row].data[column]
|
|
len = metrics.width(str(val) + "MM")
|
|
max = len if len > max else max
|
|
val = self.data_model.columnHeader(column)
|
|
len = metrics.width(str(val) + "MM")
|
|
max = len if len > max else max
|
|
self.view.setColumnWidth(column, max)
|
|
|
|
def ResizeColumnsToContents(self):
|
|
n = min(self.data_model.child_count, 100)
|
|
if n < 1:
|
|
# No data yet, so connect a signal to notify when there is
|
|
self.data_model.rowsInserted.connect(self.UpdateColumnWidths)
|
|
return
|
|
columns = self.data_model.columnCount()
|
|
for i in xrange(columns):
|
|
self.ResizeColumnToContents(i, n)
|
|
|
|
def UpdateColumnWidths(self, *x):
|
|
# This only needs to be done once, so disconnect the signal now
|
|
self.data_model.rowsInserted.disconnect(self.UpdateColumnWidths)
|
|
self.ResizeColumnsToContents()
|
|
|
|
# Table window
|
|
|
|
class TableWindow(QMdiSubWindow, ResizeColumnsToContentsBase):
|
|
|
|
def __init__(self, glb, table_name, parent=None):
|
|
super(TableWindow, self).__init__(parent)
|
|
|
|
self.data_model = LookupCreateModel(table_name + " Table", lambda: SQLAutoTableModel(glb, table_name))
|
|
|
|
self.model = QSortFilterProxyModel()
|
|
self.model.setSourceModel(self.data_model)
|
|
|
|
self.view = QTableView()
|
|
self.view.setModel(self.model)
|
|
self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
|
|
self.view.verticalHeader().setVisible(False)
|
|
self.view.sortByColumn(-1, Qt.AscendingOrder)
|
|
self.view.setSortingEnabled(True)
|
|
|
|
self.ResizeColumnsToContents()
|
|
|
|
self.find_bar = FindBar(self, self, True)
|
|
|
|
self.finder = ChildDataItemFinder(self.data_model)
|
|
|
|
self.fetch_bar = FetchMoreRecordsBar(self.data_model, self)
|
|
|
|
self.vbox = VBox(self.view, self.find_bar.Widget(), self.fetch_bar.Widget())
|
|
|
|
self.setWidget(self.vbox.Widget())
|
|
|
|
AddSubWindow(glb.mainwindow.mdi_area, self, table_name + " Table")
|
|
|
|
def Find(self, value, direction, pattern, context):
|
|
self.view.setFocus()
|
|
self.find_bar.Busy()
|
|
self.finder.Find(value, direction, pattern, context, self.FindDone)
|
|
|
|
def FindDone(self, row):
|
|
self.find_bar.Idle()
|
|
if row >= 0:
|
|
self.view.setCurrentIndex(self.model.index(row, 0, QModelIndex()))
|
|
else:
|
|
self.find_bar.NotFound()
|
|
|
|
# Table list
|
|
|
|
def GetTableList(glb):
|
|
tables = []
|
|
query = QSqlQuery(glb.db)
|
|
if glb.dbref.is_sqlite3:
|
|
QueryExec(query, "SELECT name FROM sqlite_master WHERE type IN ( 'table' , 'view' ) ORDER BY name")
|
|
else:
|
|
QueryExec(query, "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type IN ( 'BASE TABLE' , 'VIEW' ) ORDER BY table_name")
|
|
while query.next():
|
|
tables.append(query.value(0))
|
|
if glb.dbref.is_sqlite3:
|
|
tables.append("sqlite_master")
|
|
else:
|
|
tables.append("information_schema.tables")
|
|
tables.append("information_schema.views")
|
|
tables.append("information_schema.columns")
|
|
return tables
|
|
|
|
# Action Definition
|
|
|
|
def CreateAction(label, tip, callback, parent=None, shortcut=None):
|
|
action = QAction(label, parent)
|
|
if shortcut != None:
|
|
action.setShortcuts(shortcut)
|
|
action.setStatusTip(tip)
|
|
action.triggered.connect(callback)
|
|
return action
|
|
|
|
# Typical application actions
|
|
|
|
def CreateExitAction(app, parent=None):
|
|
return CreateAction("&Quit", "Exit the application", app.closeAllWindows, parent, QKeySequence.Quit)
|
|
|
|
# Typical MDI actions
|
|
|
|
def CreateCloseActiveWindowAction(mdi_area):
|
|
return CreateAction("Cl&ose", "Close the active window", mdi_area.closeActiveSubWindow, mdi_area)
|
|
|
|
def CreateCloseAllWindowsAction(mdi_area):
|
|
return CreateAction("Close &All", "Close all the windows", mdi_area.closeAllSubWindows, mdi_area)
|
|
|
|
def CreateTileWindowsAction(mdi_area):
|
|
return CreateAction("&Tile", "Tile the windows", mdi_area.tileSubWindows, mdi_area)
|
|
|
|
def CreateCascadeWindowsAction(mdi_area):
|
|
return CreateAction("&Cascade", "Cascade the windows", mdi_area.cascadeSubWindows, mdi_area)
|
|
|
|
def CreateNextWindowAction(mdi_area):
|
|
return CreateAction("Ne&xt", "Move the focus to the next window", mdi_area.activateNextSubWindow, mdi_area, QKeySequence.NextChild)
|
|
|
|
def CreatePreviousWindowAction(mdi_area):
|
|
return CreateAction("Pre&vious", "Move the focus to the previous window", mdi_area.activatePreviousSubWindow, mdi_area, QKeySequence.PreviousChild)
|
|
|
|
# Typical MDI window menu
|
|
|
|
class WindowMenu():
|
|
|
|
def __init__(self, mdi_area, menu):
|
|
self.mdi_area = mdi_area
|
|
self.window_menu = menu.addMenu("&Windows")
|
|
self.close_active_window = CreateCloseActiveWindowAction(mdi_area)
|
|
self.close_all_windows = CreateCloseAllWindowsAction(mdi_area)
|
|
self.tile_windows = CreateTileWindowsAction(mdi_area)
|
|
self.cascade_windows = CreateCascadeWindowsAction(mdi_area)
|
|
self.next_window = CreateNextWindowAction(mdi_area)
|
|
self.previous_window = CreatePreviousWindowAction(mdi_area)
|
|
self.window_menu.aboutToShow.connect(self.Update)
|
|
|
|
def Update(self):
|
|
self.window_menu.clear()
|
|
sub_window_count = len(self.mdi_area.subWindowList())
|
|
have_sub_windows = sub_window_count != 0
|
|
self.close_active_window.setEnabled(have_sub_windows)
|
|
self.close_all_windows.setEnabled(have_sub_windows)
|
|
self.tile_windows.setEnabled(have_sub_windows)
|
|
self.cascade_windows.setEnabled(have_sub_windows)
|
|
self.next_window.setEnabled(have_sub_windows)
|
|
self.previous_window.setEnabled(have_sub_windows)
|
|
self.window_menu.addAction(self.close_active_window)
|
|
self.window_menu.addAction(self.close_all_windows)
|
|
self.window_menu.addSeparator()
|
|
self.window_menu.addAction(self.tile_windows)
|
|
self.window_menu.addAction(self.cascade_windows)
|
|
self.window_menu.addSeparator()
|
|
self.window_menu.addAction(self.next_window)
|
|
self.window_menu.addAction(self.previous_window)
|
|
if sub_window_count == 0:
|
|
return
|
|
self.window_menu.addSeparator()
|
|
nr = 1
|
|
for sub_window in self.mdi_area.subWindowList():
|
|
label = str(nr) + " " + sub_window.name
|
|
if nr < 10:
|
|
label = "&" + label
|
|
action = self.window_menu.addAction(label)
|
|
action.setCheckable(True)
|
|
action.setChecked(sub_window == self.mdi_area.activeSubWindow())
|
|
action.triggered.connect(lambda x=nr: self.setActiveSubWindow(x))
|
|
self.window_menu.addAction(action)
|
|
nr += 1
|
|
|
|
def setActiveSubWindow(self, nr):
|
|
self.mdi_area.setActiveSubWindow(self.mdi_area.subWindowList()[nr - 1])
|
|
|
|
# Font resize
|
|
|
|
def ResizeFont(widget, diff):
|
|
font = widget.font()
|
|
sz = font.pointSize()
|
|
font.setPointSize(sz + diff)
|
|
widget.setFont(font)
|
|
|
|
def ShrinkFont(widget):
|
|
ResizeFont(widget, -1)
|
|
|
|
def EnlargeFont(widget):
|
|
ResizeFont(widget, 1)
|
|
|
|
# Unique name for sub-windows
|
|
|
|
def NumberedWindowName(name, nr):
|
|
if nr > 1:
|
|
name += " <" + str(nr) + ">"
|
|
return name
|
|
|
|
def UniqueSubWindowName(mdi_area, name):
|
|
nr = 1
|
|
while True:
|
|
unique_name = NumberedWindowName(name, nr)
|
|
ok = True
|
|
for sub_window in mdi_area.subWindowList():
|
|
if sub_window.name == unique_name:
|
|
ok = False
|
|
break
|
|
if ok:
|
|
return unique_name
|
|
nr += 1
|
|
|
|
# Add a sub-window
|
|
|
|
def AddSubWindow(mdi_area, sub_window, name):
|
|
unique_name = UniqueSubWindowName(mdi_area, name)
|
|
sub_window.setMinimumSize(200, 100)
|
|
sub_window.resize(800, 600)
|
|
sub_window.setWindowTitle(unique_name)
|
|
sub_window.setAttribute(Qt.WA_DeleteOnClose)
|
|
sub_window.setWindowIcon(sub_window.style().standardIcon(QStyle.SP_FileIcon))
|
|
sub_window.name = unique_name
|
|
mdi_area.addSubWindow(sub_window)
|
|
sub_window.show()
|
|
|
|
# Main window
|
|
|
|
class MainWindow(QMainWindow):
|
|
|
|
def __init__(self, glb, parent=None):
|
|
super(MainWindow, self).__init__(parent)
|
|
|
|
self.glb = glb
|
|
|
|
self.setWindowTitle("Exported SQL Viewer: " + glb.dbname)
|
|
self.setWindowIcon(self.style().standardIcon(QStyle.SP_ComputerIcon))
|
|
self.setMinimumSize(200, 100)
|
|
|
|
self.mdi_area = QMdiArea()
|
|
self.mdi_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
|
|
self.mdi_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
|
|
|
|
self.setCentralWidget(self.mdi_area)
|
|
|
|
menu = self.menuBar()
|
|
|
|
file_menu = menu.addMenu("&File")
|
|
file_menu.addAction(CreateExitAction(glb.app, self))
|
|
|
|
edit_menu = menu.addMenu("&Edit")
|
|
edit_menu.addAction(CreateAction("&Find...", "Find items", self.Find, self, QKeySequence.Find))
|
|
edit_menu.addAction(CreateAction("Fetch &more records...", "Fetch more records", self.FetchMoreRecords, self, [QKeySequence(Qt.Key_F8)]))
|
|
edit_menu.addAction(CreateAction("&Shrink Font", "Make text smaller", self.ShrinkFont, self, [QKeySequence("Ctrl+-")]))
|
|
edit_menu.addAction(CreateAction("&Enlarge Font", "Make text bigger", self.EnlargeFont, self, [QKeySequence("Ctrl++")]))
|
|
|
|
reports_menu = menu.addMenu("&Reports")
|
|
reports_menu.addAction(CreateAction("Context-Sensitive Call &Graph", "Create a new window containing a context-sensitive call graph", self.NewCallGraph, self))
|
|
|
|
self.EventMenu(GetEventList(glb.db), reports_menu)
|
|
|
|
self.TableMenu(GetTableList(glb), menu)
|
|
|
|
self.window_menu = WindowMenu(self.mdi_area, menu)
|
|
|
|
def Find(self):
|
|
win = self.mdi_area.activeSubWindow()
|
|
if win:
|
|
try:
|
|
win.find_bar.Activate()
|
|
except:
|
|
pass
|
|
|
|
def FetchMoreRecords(self):
|
|
win = self.mdi_area.activeSubWindow()
|
|
if win:
|
|
try:
|
|
win.fetch_bar.Activate()
|
|
except:
|
|
pass
|
|
|
|
def ShrinkFont(self):
|
|
win = self.mdi_area.activeSubWindow()
|
|
ShrinkFont(win.view)
|
|
|
|
def EnlargeFont(self):
|
|
win = self.mdi_area.activeSubWindow()
|
|
EnlargeFont(win.view)
|
|
|
|
def EventMenu(self, events, reports_menu):
|
|
branches_events = 0
|
|
for event in events:
|
|
event = event.split(":")[0]
|
|
if event == "branches":
|
|
branches_events += 1
|
|
dbid = 0
|
|
for event in events:
|
|
dbid += 1
|
|
event = event.split(":")[0]
|
|
if event == "branches":
|
|
label = "All branches" if branches_events == 1 else "All branches " + "(id=" + dbid + ")"
|
|
reports_menu.addAction(CreateAction(label, "Create a new window displaying branch events", lambda x=dbid: self.NewBranchView(x), self))
|
|
|
|
def TableMenu(self, tables, menu):
|
|
table_menu = menu.addMenu("&Tables")
|
|
for table in tables:
|
|
table_menu.addAction(CreateAction(table, "Create a new window containing a table view", lambda t=table: self.NewTableView(t), self))
|
|
|
|
def NewCallGraph(self):
|
|
CallGraphWindow(self.glb, self)
|
|
|
|
def NewBranchView(self, event_id):
|
|
BranchWindow(self.glb, event_id, "", "", self)
|
|
|
|
def NewTableView(self, table_name):
|
|
TableWindow(self.glb, table_name, self)
|
|
|
|
# XED Disassembler
|
|
|
|
class xed_state_t(Structure):
|
|
|
|
_fields_ = [
|
|
("mode", c_int),
|
|
("width", c_int)
|
|
]
|
|
|
|
class XEDInstruction():
|
|
|
|
def __init__(self, libxed):
|
|
# Current xed_decoded_inst_t structure is 192 bytes. Use 512 to allow for future expansion
|
|
xedd_t = c_byte * 512
|
|
self.xedd = xedd_t()
|
|
self.xedp = addressof(self.xedd)
|
|
libxed.xed_decoded_inst_zero(self.xedp)
|
|
self.state = xed_state_t()
|
|
self.statep = addressof(self.state)
|
|
# Buffer for disassembled instruction text
|
|
self.buffer = create_string_buffer(256)
|
|
self.bufferp = addressof(self.buffer)
|
|
|
|
class LibXED():
|
|
|
|
def __init__(self):
|
|
self.libxed = CDLL("libxed.so")
|
|
|
|
self.xed_tables_init = self.libxed.xed_tables_init
|
|
self.xed_tables_init.restype = None
|
|
self.xed_tables_init.argtypes = []
|
|
|
|
self.xed_decoded_inst_zero = self.libxed.xed_decoded_inst_zero
|
|
self.xed_decoded_inst_zero.restype = None
|
|
self.xed_decoded_inst_zero.argtypes = [ c_void_p ]
|
|
|
|
self.xed_operand_values_set_mode = self.libxed.xed_operand_values_set_mode
|
|
self.xed_operand_values_set_mode.restype = None
|
|
self.xed_operand_values_set_mode.argtypes = [ c_void_p, c_void_p ]
|
|
|
|
self.xed_decoded_inst_zero_keep_mode = self.libxed.xed_decoded_inst_zero_keep_mode
|
|
self.xed_decoded_inst_zero_keep_mode.restype = None
|
|
self.xed_decoded_inst_zero_keep_mode.argtypes = [ c_void_p ]
|
|
|
|
self.xed_decode = self.libxed.xed_decode
|
|
self.xed_decode.restype = c_int
|
|
self.xed_decode.argtypes = [ c_void_p, c_void_p, c_uint ]
|
|
|
|
self.xed_format_context = self.libxed.xed_format_context
|
|
self.xed_format_context.restype = c_uint
|
|
self.xed_format_context.argtypes = [ c_int, c_void_p, c_void_p, c_int, c_ulonglong, c_void_p, c_void_p ]
|
|
|
|
self.xed_tables_init()
|
|
|
|
def Instruction(self):
|
|
return XEDInstruction(self)
|
|
|
|
def SetMode(self, inst, mode):
|
|
if mode:
|
|
inst.state.mode = 4 # 32-bit
|
|
inst.state.width = 4 # 4 bytes
|
|
else:
|
|
inst.state.mode = 1 # 64-bit
|
|
inst.state.width = 8 # 8 bytes
|
|
self.xed_operand_values_set_mode(inst.xedp, inst.statep)
|
|
|
|
def DisassembleOne(self, inst, bytes_ptr, bytes_cnt, ip):
|
|
self.xed_decoded_inst_zero_keep_mode(inst.xedp)
|
|
err = self.xed_decode(inst.xedp, bytes_ptr, bytes_cnt)
|
|
if err:
|
|
return 0, ""
|
|
# Use AT&T mode (2), alternative is Intel (3)
|
|
ok = self.xed_format_context(2, inst.xedp, inst.bufferp, sizeof(inst.buffer), ip, 0, 0)
|
|
if not ok:
|
|
return 0, ""
|
|
# Return instruction length and the disassembled instruction text
|
|
# For now, assume the length is in byte 166
|
|
return inst.xedd[166], inst.buffer.value
|
|
|
|
def TryOpen(file_name):
|
|
try:
|
|
return open(file_name, "rb")
|
|
except:
|
|
return None
|
|
|
|
def Is64Bit(f):
|
|
result = sizeof(c_void_p)
|
|
# ELF support only
|
|
pos = f.tell()
|
|
f.seek(0)
|
|
header = f.read(7)
|
|
f.seek(pos)
|
|
magic = header[0:4]
|
|
eclass = ord(header[4])
|
|
encoding = ord(header[5])
|
|
version = ord(header[6])
|
|
if magic == chr(127) + "ELF" and eclass > 0 and eclass < 3 and encoding > 0 and encoding < 3 and version == 1:
|
|
result = True if eclass == 2 else False
|
|
return result
|
|
|
|
# Global data
|
|
|
|
class Glb():
|
|
|
|
def __init__(self, dbref, db, dbname):
|
|
self.dbref = dbref
|
|
self.db = db
|
|
self.dbname = dbname
|
|
self.home_dir = os.path.expanduser("~")
|
|
self.buildid_dir = os.getenv("PERF_BUILDID_DIR")
|
|
if self.buildid_dir:
|
|
self.buildid_dir += "/.build-id/"
|
|
else:
|
|
self.buildid_dir = self.home_dir + "/.debug/.build-id/"
|
|
self.app = None
|
|
self.mainwindow = None
|
|
self.instances_to_shutdown_on_exit = weakref.WeakSet()
|
|
try:
|
|
self.disassembler = LibXED()
|
|
self.have_disassembler = True
|
|
except:
|
|
self.have_disassembler = False
|
|
|
|
def FileFromBuildId(self, build_id):
|
|
file_name = self.buildid_dir + build_id[0:2] + "/" + build_id[2:] + "/elf"
|
|
return TryOpen(file_name)
|
|
|
|
def FileFromNamesAndBuildId(self, short_name, long_name, build_id):
|
|
# Assume current machine i.e. no support for virtualization
|
|
if short_name[0:7] == "[kernel" and os.path.basename(long_name) == "kcore":
|
|
file_name = os.getenv("PERF_KCORE")
|
|
f = TryOpen(file_name) if file_name else None
|
|
if f:
|
|
return f
|
|
# For now, no special handling if long_name is /proc/kcore
|
|
f = TryOpen(long_name)
|
|
if f:
|
|
return f
|
|
f = self.FileFromBuildId(build_id)
|
|
if f:
|
|
return f
|
|
return None
|
|
|
|
def AddInstanceToShutdownOnExit(self, instance):
|
|
self.instances_to_shutdown_on_exit.add(instance)
|
|
|
|
# Shutdown any background processes or threads
|
|
def ShutdownInstances(self):
|
|
for x in self.instances_to_shutdown_on_exit:
|
|
try:
|
|
x.Shutdown()
|
|
except:
|
|
pass
|
|
|
|
# Database reference
|
|
|
|
class DBRef():
|
|
|
|
def __init__(self, is_sqlite3, dbname):
|
|
self.is_sqlite3 = is_sqlite3
|
|
self.dbname = dbname
|
|
|
|
def Open(self, connection_name):
|
|
dbname = self.dbname
|
|
if self.is_sqlite3:
|
|
db = QSqlDatabase.addDatabase("QSQLITE", connection_name)
|
|
else:
|
|
db = QSqlDatabase.addDatabase("QPSQL", connection_name)
|
|
opts = dbname.split()
|
|
for opt in opts:
|
|
if "=" in opt:
|
|
opt = opt.split("=")
|
|
if opt[0] == "hostname":
|
|
db.setHostName(opt[1])
|
|
elif opt[0] == "port":
|
|
db.setPort(int(opt[1]))
|
|
elif opt[0] == "username":
|
|
db.setUserName(opt[1])
|
|
elif opt[0] == "password":
|
|
db.setPassword(opt[1])
|
|
elif opt[0] == "dbname":
|
|
dbname = opt[1]
|
|
else:
|
|
dbname = opt
|
|
|
|
db.setDatabaseName(dbname)
|
|
if not db.open():
|
|
raise Exception("Failed to open database " + dbname + " error: " + db.lastError().text())
|
|
return db, dbname
|
|
|
|
# Main
|
|
|
|
def Main():
|
|
if (len(sys.argv) < 2):
|
|
print >> sys.stderr, "Usage is: exported-sql-viewer.py <database name>"
|
|
raise Exception("Too few arguments")
|
|
|
|
dbname = sys.argv[1]
|
|
|
|
is_sqlite3 = False
|
|
try:
|
|
f = open(dbname)
|
|
if f.read(15) == "SQLite format 3":
|
|
is_sqlite3 = True
|
|
f.close()
|
|
except:
|
|
pass
|
|
|
|
dbref = DBRef(is_sqlite3, dbname)
|
|
db, dbname = dbref.Open("main")
|
|
glb = Glb(dbref, db, dbname)
|
|
app = QApplication(sys.argv)
|
|
glb.app = app
|
|
mainwindow = MainWindow(glb)
|
|
glb.mainwindow = mainwindow
|
|
mainwindow.show()
|
|
err = app.exec_()
|
|
glb.ShutdownInstances()
|
|
db.close()
|
|
sys.exit(err)
|
|
|
|
if __name__ == "__main__":
|
|
Main()
|