vdb.gui

1 2 from types import * 3 from vtrace import * 4 5 import sys 6 import vdb 7 import gtk 8 import gtk.gdk as gdk 9 import pygtk 10 import pydoc 11 import struct 12 import getopt 13 import inspect 14 import gtk.glade 15 import traceback 16 import threading 17 18 import time 19 import pango 20 import gobject 21 import vtrace 22 import vwidget.main as vw_main 23 import vdb.gui.extensions 24 25 import vstruct 26 import vstruct.primitives as vs_prims 27 28 import vwidget.layout as vw_layout 29 import vwidget.memview as vw_memview 30 import vwidget.vwvtrace as vw_vtrace 31 import vwidget.views as vw_views 32 33 from envi.threads import firethread 34 from vwidget.main import idlethread, idlethreadsync 35 36 symtype_names = { 37 SYM_MISC:"Unknown", 38 SYM_GLOBAL:"Global", 39 SYM_LOCAL:"Local", 40 SYM_FUNCTION:"Function", 41 SYM_SECTION:"Section", 42 SYM_META:"Meta"}

43 44 -def hex(num):

45 return "0x%.8x" % num

46 47 stylerc = """ 48 49 style "kenshoto" { 50 51 font = "Monospace 10" 52 53 bg[NORMAL] = {0.1, 0.1, 0.1} 54 fg[NORMAL] = {0.0, 1.0, 0.0} 55 56 bg[SELECTED] = {0.0, 1.0, 0.0} 57 fg[SELECTED] = {0.0, 0.0, 0.0} 58 59 bg[PRELIGHT] = {0.0, 1.0, 0.0} 60 fg[PRELIGHT] = {0.0, 0.0, 0.0} 61 62 bg[ACTIVE] = {0.0, 1.0, 0.0} 63 fg[ACTIVE] = {0.0, 0.0, 0.0} 64 65 bg[INSENSITIVE] = {0.2, 0.2, 0.2} 66 fg[INSENSITIVE] = {1.0, 1.0, 1.0} 67 68 } 69 70 #widget_class "*" style "kenshoto" 71 72 gtk-font-name = "Monospace 10" 73 74 """

75 76 -class VdbGui(vw_layout.LayoutManager, Notifier):

77

78 - def __init__(self, db, ismain=True):

79 vw_layout.LayoutManager.__init__(self) 80 81 self.db = db 82 db.gui = self 83 self.db.registerNotifier(NOTIFY_ALL, self) 84 self.ismain = ismain 85 86 self.winactive = False 87 88 gtk.rc_parse_string(stylerc) 89 90 defgeom = (20,20,600,450) 91 self.defgeom = defgeom 92 93 self.addWindowClass(VdbMainWindow, args=(db,self), defgeom=defgeom) 94 self.addWindowClass(VdbMemoryWindow, args=(db,self), defgeom=defgeom) 95 self.addWindowClass(VdbMemoryMapWindow, args=(db,self), defgeom=defgeom) 96 self.addWindowClass(VdbFileDescWindow, args=(db,self), defgeom=defgeom) 97 self.addWindowClass(VdbRegisterWindow, args=(db,self), defgeom=defgeom) 98 99 mainwin = None 100 if self.db.vdbhome: 101 lfile = os.path.join(self.db.vdbhome, "vdb.lyt2") 102 if os.path.exists(lfile): 103 self.loadLayoutFile(file(lfile,"rb")) 104 105 self.mainwin = self.getOrCreateWindow('VdbMainWindow') 106 107 t = self.db.trace 108 if t.isAttached() and not t.isRunning(): 109 self.setTraceWindowsActive(True) 110 else: 111 self.setTraceWindowsActive(False) 112 113 vdb.gui.extensions.loadGuiExtensions(db, self)

114

115 - def addExtensionWindow(self, name, winclass):

116 self.addWindowClass(winclass, args=(self.db, self), defgeom=self.defgeom, clsname=name) 117 self.mainwin.menubar.addField("Extensions.%s" % name, self.createExtensionWindow, args=(name,))

118

119 - def createExtensionWindow(self, item, name):

120 self.createWindow(name)

121

122 - def saveVdbLayout(self, *args):

123 if self.db.vdbhome: 124 lfile = os.path.join(self.db.vdbhome, "vdb.lyt2") 125 self.saveLayoutFile(file(lfile, "wb"))

126

127 - def createWindow(self, clsname):

128 win = vw_layout.LayoutManager.createWindow(self, clsname) 129 win.setTraceWindowActive(self.winactive) 130 return win

131

132 - def setTraceWindowsActive(self, active=True):

133 self.winactive = active 134 for win in self.getManagedWindows(): 135 try: 136 win.setTraceWindowActive(active) 137 except Exception, e: 138 #FIXME ugly 139 print "ERROR: setTraceWindowsActive() for %s: %s" % (win.__class__.__name__, e)

140 141 @idlethreadsync

142 - def notify(self, event, trace):

143 144 if event in [vtrace.NOTIFY_CONTINUE, vtrace.NOTIFY_DETACH, vtrace.NOTIFY_EXIT]: 145 self.setTraceWindowsActive(False) 146 147 else: 148 # If the trace is just going to run again, skip the update. 149 if not trace.shouldRunAgain(): 150 self.setTraceWindowsActive(True)

151

152 -class VdbWindow(vw_layout.LayoutWindow):

153 """ 154 A VDB window is the basis for all vdb GUI windows. 155 """

156 - def __init__(self, db, gui):

157 vw_layout.LayoutWindow.__init__(self) 158 self.db = db 159 self.gui = gui

160

161 - def setTraceWindowActive(self, active):

162 pass

163

164 -class VdbRegisterWindow(VdbWindow):

165

166 - def __init__(self, db, gui):

167 VdbWindow.__init__(self, db, gui) 168 self.set_title("Registers") 169 trace = vdb.VdbTrace(db) 170 self.regview = vw_views.VTextView() 171 self.regview.textview.set_editable(False) 172 arch = trace.getMeta("Architecture") 173 self.reglist = db.config.get("RegisterView",arch).split(",") 174 self.add(self.regview) 175 176 self.regs = {} 177 self.lastthread = -1

178

179 - def getRegTag(self, regname):

180 tag = self.regview.vwGetTag(regname) 181 if tag == None: 182 tag = gtk.TextTag(regname) 183 self.regview.vwInitTag(tag, "register") 184 return tag

185

186 - def getVaTag(self, va):

187 vaname = "%.8x" % va 188 tag = self.regview.vwGetTag(vaname) 189 if tag == None: 190 tag = gtk.TextTag(vaname) 191 self.regview.vwInitTag(tag, "va", self.vaTagEvent) 192 tag.va = va 193 return tag

194

195 - def vaTagEvent(self, tag, textview, event, iter):

196 if event.type == gdk._2BUTTON_PRESS: 197 memwin = self.gui.createWindow("VdbMemoryWindow") 198 memwin.setExpression("0x%.8x" % tag.va)

199

200 - def update(self):

201 trace = self.db.getTrace() 202 thrid = trace.getMeta("ThreadId") 203 if thrid != self.lastthread: 204 self.regs = {} 205 206 regs = trace.getRegisters() 207 self.regview.vwClearText() 208 209 iter = self.regview.vwGetAppendIter() 210 211 for rname in self.reglist: 212 newval = regs.get(rname, 0) 213 oldval = self.regs.get(rname, newval) 214 215 deftag = self.regview.vwGetTag("default") 216 regtag = self.getRegTag(rname) 217 vatag = deftag 218 if trace.isValidPointer(newval): 219 vatag = self.getVaTag(newval) 220 221 self.regview.vwInsertText(rname, iter=iter, tag=regtag) 222 self.regview.vwInsertText(": ", iter=iter, tag=deftag) 223 self.regview.vwInsertText("0x%.8x" % newval, iter=iter, tag=vatag) 224 self.regview.vwInsertText("\n", iter=iter, tag=deftag) 225 226 self.lastthread = thrid 227 self.regs = regs

228

229 - def setTraceWindowActive(self, active):

230 if active: 231 self.regview.set_sensitive(True) 232 self.update() 233 else: 234 self.regview.set_sensitive(False)

235

236 -class VdbViewWindow(VdbWindow):

237

238 - def __init__(self, db, gui, vtclass):

239 VdbWindow.__init__(self, db, gui) 240 trace = vdb.VdbTrace(db) 241 self.vtview = vtclass(trace) 242 self.add(self.vtview)

243

244 - def setTraceWindowActive(self, active):

245 if active: 246 self.vtview.set_sensitive(True) 247 self.vtview.vwLoad() 248 else: 249 self.vtview.set_sensitive(False)

250

251 -class VdbFileDescWindow(VdbViewWindow):

252 - def __init__(self, db, gui):

253 VdbViewWindow.__init__(self, db, gui, vw_vtrace.FileDescView) 254 self.set_title("File Descriptors")

255

256 -class VdbMemoryMapWindow(VdbViewWindow):

257 - def __init__(self, db, gui):

258 VdbViewWindow.__init__(self, db, gui, vw_vtrace.MemoryMapView) 259 self.vtview.treeview.connect("row_activated", self.mapActivated) 260 self.set_title("Memory Maps")

261

262 - def getWindowName(self):

263 return self.__class__.__name__

264

265 - def mapActivated(self, tree, path, column):

266 model = self.vtview.model 267 iter = model.get_iter(path) 268 base = model.get_value(iter, 0) 269 memwin = self.gui.createWindow("VdbMemoryWindow") 270 memwin.setExpression("0x%.8x" % base)

271 272 import vwidget.windows as vw_windows

273 274 -class VdbMainWindow(vw_windows.MainWindow):

275

276 - def __init__(self, db, gui):

277 278 trace = vdb.VdbTrace(db) 279 self.db = db 280 281 # The vdb instance *is* the cli object. 282 vw_windows.MainWindow.__init__(self, db, trace, syms=trace) 283 284 self.gui = gui 285 self.set_title("Vdb") 286 self.menubar.addField("File.Save.Layout", self.file_save_layout) 287 self.menubar.addField("File.Save.Snapshot", self.file_save_snapshot) 288 self.menubar.addField("File.Quit", self.file_quit) 289 self.menubar.addField("Edit.Copy", self.file_edit_copy) 290 self.menubar.addField("View.Memory Window", self.file_view_memwin) 291 self.menubar.addField("View.Memory Maps", self.file_view_memmaps) 292 self.menubar.addField("View.Registers", self.file_view_registers) 293 self.menubar.addField("View.File Descriptors", self.file_view_filedesc) 294 self.menubar.addField("Tools.Python", self.tools_python) 295 296 # On delete, lets save off the layout... 297 self.connect('delete_event', self._mainDelete)

298 299 #descr = pango.FontDescription("Monospace 12") 300 #entry.modify_font(descr) 301

302 - def getMainToolbar(self):

303 trace = vdb.VdbTrace(self.db) 304 return vw_vtrace.TraceToolBar(trace)

305

306 - def setTraceWindowActive(self, active):

307 pass

308

309 - def tools_python(self, *args):

310 import vwidget.pydialog as vw_pydialog 311 l = self.db.getExpressionLocals() 312 p = vw_pydialog.PyDialog(l) 313 p.show()

314

315 - def file_view_registers(self, *args):

316 self.gui.createWindow("VdbRegisterWindow")

317

318 - def file_view_memmaps(self, *args):

319 self.gui.createWindow("VdbMemoryMapWindow")

320

321 - def file_view_memwin(self, *args):

322 self.gui.createWindow("VdbMemoryWindow")

323

324 - def file_view_filedesc(self, *args):

325 self.gui.createWindow("VdbFileDescWindow")

326

327 - def file_edit_copy(self, *args):

328 print "copy"

329

330 - def _mainDelete(self, *args):

331 self.db.do_quit("") 332 self.db.shutdown.set() 333 self.gui.saveVdbLayout() 334 self.gui.deleteAllWindows(omit=self) 335 if self.gui.ismain: 336 vw_main.shutdown()

337

338 - def file_quit(self, *args):

339 self.gui.deleteAllWindows()

340

341 - def file_save_snapshot(self, *args):

342 print "Save Snapshot!"

343

344 - def file_save_layout(self, *args):

345 print "SAVE LAYOUT"

346

347 -class VdbMemoryView(vw_memview.MemoryView):

348 """ 349 Extend so we can override right click popups 350 """

351 - def __init__(self, trace, vdbwin):

352 vw_memview.MemoryView.__init__(self, trace, syms=trace) 353 self.vdbwin = vdbwin

354

355 - def checkRender(self, va, size=None, rend=None):

356 self.render(va, size, rend)

357

358 - def vwGetPopup(self, textview, menu):

359 va = self.selectva 360 361 if va != None: 362 363 pos = 0 364 365 # Breakpoints 366 bm = gtk.MenuItem("Breakpoint") 367 bm.connect("activate", self.popBreakpoint, va) 368 menu.insert(bm, pos) 369 pos += 1 370 371 rm = gtk.MenuItem("Run To Here") 372 rm.connect("activate", self.popRunToHere, va) 373 menu.insert(rm, pos) 374 pos += 1 375 376 # Watchpoints 377 wmenu = gtk.Menu() 378 wm = gtk.MenuItem("Watch") 379 wm.set_submenu(wmenu) 380 381 wmread = gtk.MenuItem("Reads") 382 wmread.connect("activate", self.popWatchRead, va) 383 wmwrite = gtk.MenuItem("Writes") 384 wmwrite.connect("activate", self.popWatchWrite, va) 385 386 wmenu.append(wmread) 387 wmenu.append(wmwrite) 388 389 menu.insert(wm, pos) 390 pos += 1 391 392 # Renderers 393 rmenu = gtk.Menu() 394 mn = gtk.MenuItem("Render") 395 mn.set_submenu(rmenu) 396 for name in self.vdbwin.db.canvas.getRendererNames(): 397 i = gtk.MenuItem(name) 398 i.connect("activate", self.reRender, name) 399 rmenu.append(i) 400 401 menu.insert(mn,pos) 402 pos += 1 403 404 menu.show_all()

405 406 @firethread

407 - def popRunToHere(self, item, va):

408 self.vdbwin.db.trace.run(until=va)

409

410 - def popBreakpoint(self, item, va):

411 bp = vtrace.Breakpoint(va) 412 self.vdbwin.db.trace.addBreakpoint(bp)

413

414 - def popWatchRead(self, item, va):

415 bp = vtrace.Watchpoint(va, perms="r") 416 self.vdbwin.db.trace.addBreakpoint(bp)

417

418 - def popWatchWrite(self, item, va):

419 bp = vtrace.Watchpoint(va) 420 self.vdbwin.db.trace.addBreakpoint(bp)

421

422 - def reRender(self, item, name):

423 self.vdbwin.setWindowState(("0x%.8x" % self.selectva, "256", name))

424

425 -class VdbMemoryWindow(vw_memview.MemoryWindow):

426 - def __init__(self, db, gui):

427 self.db = db 428 self.gui = gui 429 trace = vdb.VdbTrace(db) 430 canvas = VdbMemoryView(trace, self) 431 for rname in db.canvas.getRendererNames(): 432 canvas.addRenderer(rname, db.canvas.getRenderer(rname)) 433 434 vw_memview.MemoryWindow.__init__(self, canvas)

435

436 - def setTraceWindowActive(self, active=True):

437 if active: 438 self.vbox.set_sensitive(True) 439 self.updateMemoryView() 440 else: 441 self.vbox.set_sensitive(False)

442

443 - def updateMemoryView(self, *args):

444 445 trace = self.db.getTrace() 446 if (not trace.isAttached()) or trace.isRunning(): 447 return 448 449 return vw_memview.MemoryWindow.updateMemoryView(self, *args)

450

451 -def main(db):

452 vw_main.mainthread() 453 vg = VdbGui(db) 454 vw_main.main()

455

Source Code for Package vdb.gui