From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 22434 invoked by alias); 2 Jun 2008 19:07:37 -0000 Received: (qmail 22319 invoked by uid 9697); 2 Jun 2008 19:07:36 -0000 Date: Mon, 02 Jun 2008 19:07:00 -0000 Message-ID: <20080602190736.22301.qmail@sourceware.org> From: pmachata@sourceware.org To: frysk-cvs@sourceware.org Subject: [SCM] master: Mention support of "#" syntax in NEWS X-Git-Refname: refs/heads/master X-Git-Reftype: branch X-Git-Oldrev: 2d225df716914a76f96dacd506c4becbebb551cb X-Git-Newrev: f70532060f15f8058128ea41287a781eab8380a6 Mailing-List: contact frysk-cvs-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Post: List-Help: , Sender: frysk-cvs-owner@sourceware.org Reply-To: frysk@sourceware.org X-SW-Source: 2008-q2/txt/msg00315.txt.bz2 The branch, master has been updated via f70532060f15f8058128ea41287a781eab8380a6 (commit) via 6be7f41f2bc64f791220913409e6677c8ec6037b (commit) via 1a2d4ac0b2706e92abdde3f18c6c9f2326186aac (commit) from 2d225df716914a76f96dacd506c4becbebb551cb (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email. - Log ----------------------------------------------------------------- commit f70532060f15f8058128ea41287a781eab8380a6 Author: Petr Machata Date: Mon Jun 2 21:02:57 2008 +0200 Mention support of "#" syntax in NEWS commit 6be7f41f2bc64f791220913409e6677c8ec6037b Author: Petr Machata Date: Mon Jun 2 20:47:42 2008 +0200 Ftrace retracts breakpoints when the library is unmapped * this fixes existing problem where ftrace would report events from remapped libraries twice * but it's done in a very hackish way. Frysk doesn't actually get rid of disabled high-level breakpoints, so when library is remapped and _dl_debug_state observer triggers, it re-enables them. So right now I just mark the observer as invalid (we still need the observer to turn the stepping engine execution back on). Cleaner solution is due, maybe it's not necessary to add breakpoints second time at all... commit 1a2d4ac0b2706e92abdde3f18c6c9f2326186aac Author: Petr Machata Date: Mon Jun 2 14:12:55 2008 +0200 Fix buglet in # parser ----------------------------------------------------------------------- Summary of changes: NEWS | 5 ++ frysk-core/frysk/expr/CExpr.g | 2 + frysk-core/frysk/ftrace/ChangeLog | 5 ++ frysk-core/frysk/ftrace/Ftrace.java | 86 ++++++++++++++++++------- frysk-core/frysk/ftrace/FtraceController.java | 29 +++++++- frysk-core/frysk/ftrace/TaskTracer.java | 71 ++++++++++++++++++++- 6 files changed, 168 insertions(+), 30 deletions(-) First 500 lines of diff: diff --git a/NEWS b/NEWS index 066ea7a..05d3f76 100644 --- a/NEWS +++ b/NEWS @@ -24,6 +24,11 @@ Release 0.4, ????-??-?? parameters. Also, on subsequent runs, "-la" is always used unless other parameters are entered with the "run" or "start" command. +-> Support was added for fully-qualified symbol notation using the + standard HPD "#" syntax (e.g. "#libc.so.6#malloc"). Ftrace now + uses this notation to communicate with the user in both directions, + FHPD recognizes the syntax although can't handle it yet. + -- Release 0.3, 2008-05-09 diff --git a/frysk-core/frysk/expr/CExpr.g b/frysk-core/frysk/expr/CExpr.g index 41a33c6..df1ea00 100644 --- a/frysk-core/frysk/expr/CExpr.g +++ b/frysk-core/frysk/expr/CExpr.g @@ -684,6 +684,8 @@ PARSE_FQIDENT part = part.substring(0, m.end()); } } + else + throw new RecognitionException("Expected symbol name, got `" + part + "'."); if (!Character.isJavaIdentifierStart(part.charAt(0))) throw new RecognitionException("Invalid symbol `" + part + "'."); diff --git a/frysk-core/frysk/ftrace/ChangeLog b/frysk-core/frysk/ftrace/ChangeLog index 2e7fbc9..2d2ec7c 100644 --- a/frysk-core/frysk/ftrace/ChangeLog +++ b/frysk-core/frysk/ftrace/ChangeLog @@ -1,3 +1,8 @@ +2008-06-02 Petr Machata + + * Ftrace.java, FtraceController.java, TaskTracer.java: Retract + breakpoints when file is unmapped. + 2008-05-30 Petr Machata * PLTRule.java: Drop. The functionality is taken over by... diff --git a/frysk-core/frysk/ftrace/Ftrace.java b/frysk-core/frysk/ftrace/Ftrace.java index 95a0921..d0f9dd4 100644 --- a/frysk-core/frysk/ftrace/Ftrace.java +++ b/frysk-core/frysk/ftrace/Ftrace.java @@ -41,6 +41,7 @@ package frysk.ftrace; import java.util.HashMap; import java.util.HashSet; +import java.util.List; import java.util.Map; import java.util.Set; @@ -105,8 +106,14 @@ public class Ftrace { * ltrace what to do. */ void fileMapped(Task task, ObjectFile objf, - DwflModule module, - Driver driver); + DwflModule module, Driver driver); + + /** + * New library FILE was unmapped from task TASK. Use DRIVER + * to tell ltrace what to do. + */ + void fileUnmapped(Task task, ObjectFile objf, + DwflModule module, Driver driver); } /** @@ -151,6 +158,7 @@ public class Ftrace { void traceSymbol(Task task, DwflSymbol symbol); void tracePLTEntry(Task task, PLTEntry entry); void traceAddress(Task task, Long addrToken, long bias, ObjectFile objf); + void untrace(Task task, List traceables); } // Non-null if we're using ltrace. @@ -608,39 +616,51 @@ public class Ftrace { return null; } - public Action updateMappedFile(Task task, MemoryMapping mapping) { + private void reportMapUnmap(Task task, MemoryMapping mapping, String what) { - if (traceMmapUnmap) { - MemoryMapping.Part part0 - = (MemoryMapping.Part)mapping.parts.get(0); - long addr = part0.addressLow; - String event - = "map " + ArchFormatter.toHexString(task, addr) - + " " + mapping.path; - reporter.eventSingle(task, event); - } + MemoryMapping.Part part0 = (MemoryMapping.Part)mapping.parts.get(0); + long addr = part0.addressLow; + String event = what + + ' ' + ArchFormatter.toHexString(task, addr) + + ' ' + mapping.path; - if (this.tracingController == null) - return Action.CONTINUE; + reporter.eventSingle(task, event); + } - if (mapping.path.equals("/SYSV00000000 (deleted)")) { + private ObjectFile objectFileForMapping(MemoryMapping mapping) { + if (mapping.path.equals("/SYSV00000000 (deleted)")) // This is most probably artificial name of SYSV // shared memory "file". - return Action.CONTINUE; - } - - ObjectFile objf = ObjectFile.buildFromFile(mapping.path); - if (objf == null) - return Action.CONTINUE; + return null; - DwflModule module = getModuleForFile(task, mapping.path); + return ObjectFile.buildFromFile(mapping.path); + } + private Map getDriversForTask(Task task) { Map drivers = (Map)driversForTask.get(task); if (drivers == null) { drivers = new HashMap(); driversForTask.put(task, drivers); } + return drivers; + } + + public Action updateMappedFile(Task task, MemoryMapping mapping) { + + if (traceMmapUnmap) + reportMapUnmap(task, mapping, "map"); + + if (this.tracingController == null) + return Action.CONTINUE; + + ObjectFile objf = objectFileForMapping(mapping); + if (objf == null) + return Action.CONTINUE; + + DwflModule module = getModuleForFile(task, mapping.path); + + Map drivers = getDriversForTask(task); Driver driver = new TaskTracer(Ftrace.this, task); drivers.put(mapping.path, driver); this.tracingController.fileMapped(task, objf, module, driver); @@ -652,8 +672,26 @@ public class Ftrace { public Action updateUnmappedFile(frysk.proc.Task task, MemoryMapping mapping) { if (traceMmapUnmap) - reporter.eventSingle(task, "unmap " + mapping.path); - return Action.CONTINUE; + reportMapUnmap(task, mapping, "unmap"); + + if (this.tracingController == null) + return Action.CONTINUE; + + ObjectFile objf = objectFileForMapping(mapping); + if (objf == null) + return Action.CONTINUE; + + DwflModule module = getModuleForFile(task, mapping.path); + + Map drivers = getDriversForTask(task); + Driver driver = (Driver)drivers.get(mapping.path); + if (driver == null) + throw new AssertionError("There should be a driver for `" + mapping.path + "'."); + + this.tracingController.fileUnmapped(task, objf, module, driver); + + task.requestUnblock(this); + return Action.BLOCK; } public Action updateMappedPart(Task task, MemoryMapping mapping, diff --git a/frysk-core/frysk/ftrace/FtraceController.java b/frysk-core/frysk/ftrace/FtraceController.java index 09f064f..1eb9ff9 100644 --- a/frysk-core/frysk/ftrace/FtraceController.java +++ b/frysk-core/frysk/ftrace/FtraceController.java @@ -252,19 +252,28 @@ public class FtraceController } } - public void fileMapped(final Task task, ObjectFile objf, - DwflModule module, - final Ftrace.Driver driver) { + private List traceablesForModule(DwflModule module) { Map symbolTable = SymbolFactory.getSymbolTable(module); if (symbolTable.size() == 0) // In that case we also know there are no PLT entries, // because each PLT entry is defined on a symbol. - return; + return null; List traceables = new ArrayList(symbolTable.values()); traceables.addAll(SymbolFactory.getPLTEntries(module, symbolTable)); + return traceables; + } + + public void fileMapped(final Task task, ObjectFile objf, + DwflModule module, + final Ftrace.Driver driver) { + + List traceables = traceablesForModule(module); + if (traceables == null) + return; + try { applySymbolRules (task, objf, traceables, symRules, @@ -287,4 +296,16 @@ public class FtraceController ee.printStackTrace(); } } + + public void fileUnmapped(final Task task, ObjectFile objf, + DwflModule module, + final Ftrace.Driver driver) { + + List traceables = traceablesForModule(module); + if (traceables == null) + return; + + driver.untrace(task, traceables); + } + } diff --git a/frysk-core/frysk/ftrace/TaskTracer.java b/frysk-core/frysk/ftrace/TaskTracer.java index 95ede2e..467d3c1 100644 --- a/frysk-core/frysk/ftrace/TaskTracer.java +++ b/frysk-core/frysk/ftrace/TaskTracer.java @@ -40,7 +40,9 @@ package frysk.ftrace; import java.util.HashMap; +import java.util.Iterator; import java.util.LinkedList; +import java.util.List; import java.util.Map; import frysk.dwfl.ObjectFile; @@ -225,6 +227,8 @@ class TaskTracer { private DwflSymbol sym = null; private final boolean isPlt; + private SourceBreakpoint observing = null; + private boolean invalid = false; public FunctionEnterObserver() { this.isPlt = false; @@ -235,6 +239,22 @@ class TaskTracer this.isPlt = true; } + // Frysk doesn't get rid of disabled breakpoints, and turns + // them back on when _dl_debug_state observer triggers. In + // invalidated state, the observer turns the breakpoint back + // off everytime it's hit. + public void invalidate() { + invalid = true; + } + + public void setObserving(SourceBreakpoint breakpoint) { + this.observing = breakpoint; + } + + public SourceBreakpoint getObserving() { + return this.observing; + } + public void addSymbol(DwflSymbol symbol) { if (sym != null && sym.getAddress() != symbol.getAddress()) @@ -255,6 +275,12 @@ class TaskTracer } public void updateHit(SourceBreakpoint breakpoint, Task task, long address) { + + if (invalid) { + Ftrace.steppingEngine.continueExecution(task); + return; + } + if (!isPlt && (address < sym.getAddress() // Some symbols are reported with size 0, and for @@ -339,6 +365,12 @@ class TaskTracer // Map> private final Map symbolObserversForTask = new HashMap(); + private Long getAddress(DwflSymbol sym, PLTEntry entry) { + long addr = entry != null ? entry.getAddress() : sym.getAddress(); + Long addrL = new Long(addr); + return addrL; + } + private synchronized FunctionEnterObserver getObserver(Task task, DwflSymbol sym, PLTEntry entry) { @@ -349,8 +381,7 @@ class TaskTracer symbolObserversForTask.put(task, symbolObservers); } - long addr = entry != null ? entry.getAddress() : sym.getAddress(); - Long addrL = new Long(addr); + Long addrL = getAddress(sym, entry); FunctionEnterObserver ob = (FunctionEnterObserver)symbolObservers.get(addrL); if (ob == null) { @@ -371,6 +402,7 @@ class TaskTracer else bp = bpManager.addSymbolBreakpoint(sym); bp.addObserver(ob); + ob.setObserving(bp); bpManager.enableBreakpoint(bp, task); } return ob; @@ -398,6 +430,41 @@ class TaskTracer "at", entry.getSymbol().getAddress()); } + public void untrace(Task task, List traceables) { + + fine.log("Request to retract multiple traceables:", traceables.size()); + for (Iterator it = traceables.iterator(); it.hasNext(); ) { + Object traceable = it.next(); + + final DwflSymbol symbol; + final PLTEntry entry; + if (traceable instanceof PLTEntry) { + entry = (PLTEntry)traceable; + symbol = entry.getSymbol(); + } else { + entry = null; + symbol = (DwflSymbol)traceable; + } + + Map symbolObservers = (Map)symbolObserversForTask.get(task); + if (symbolObservers == null) + // Cool, we are not even tracing it. + return; + + Long addrL = getAddress(symbol, entry); + Object orig; + if ((orig = symbolObservers.remove(addrL)) != null) { + fine.log("Retracting", symbol, "at", addrL.longValue()); + FunctionEnterObserver ob = (FunctionEnterObserver)orig; + SourceBreakpoint bp = ob.getObserving(); + BreakpointManager bpManager + = Ftrace.steppingEngine.getBreakpointManager(); + bpManager.disableBreakpoint(bp, task); + ob.invalidate(); + } + } + } + public void traceAddress(Task task, Long addrToken, long bias, ObjectFile objf) { hooks/post-receive -- frysk system monitor/debugger