From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 29245 invoked by alias); 10 Mar 2008 18:47:44 -0000 Received: (qmail 29214 invoked by uid 9697); 10 Mar 2008 18:47:43 -0000 Date: Mon, 10 Mar 2008 18:47:00 -0000 Message-ID: <20080310184743.29199.qmail@sourceware.org> From: pmachata@sourceware.org To: frysk-cvs@sourceware.org Subject: [SCM] master: Always use syscall based mapping guard when user passed -m X-Git-Refname: refs/heads/master X-Git-Reftype: branch X-Git-Oldrev: 28062866fd08a4ae6ceffcce19f1f801638ab8c6 X-Git-Newrev: 0bb075af459281dacab34a6711754b1fbc3279fd 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-q1/txt/msg00319.txt.bz2 The branch, master has been updated via 0bb075af459281dacab34a6711754b1fbc3279fd (commit) via e01ad26aed6664a01a4d49b899e178a465cf2eb4 (commit) from 28062866fd08a4ae6ceffcce19f1f801638ab8c6 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email. - Log ----------------------------------------------------------------- commit 0bb075af459281dacab34a6711754b1fbc3279fd Author: Petr Machata Date: Mon Mar 10 19:42:05 2008 +0100 Always use syscall based mapping guard when user passed -m ... because presumable then he's interested in exact mmap/unmap order and all mappings, not just the ones that go through dynamic linker. commit e01ad26aed6664a01a4d49b899e178a465cf2eb4 Author: Petr Machata Date: Mon Mar 10 18:59:08 2008 +0100 Fix -m failing without -sym/-plt/-dyn ----------------------------------------------------------------------- Summary of changes: frysk-core/frysk/ftrace/ChangeLog | 13 ++++++++++ frysk-core/frysk/ftrace/Ftrace.java | 24 +++++++++++++---- frysk-core/frysk/ftrace/MappingGuard.java | 38 +++++++++++++++++++--------- 3 files changed, 57 insertions(+), 18 deletions(-) First 500 lines of diff: diff --git a/frysk-core/frysk/ftrace/ChangeLog b/frysk-core/frysk/ftrace/ChangeLog index 16bed51..2ca2c40 100644 --- a/frysk-core/frysk/ftrace/ChangeLog +++ b/frysk-core/frysk/ftrace/ChangeLog @@ -1,3 +1,16 @@ +2008-03-10 Petr Machata + + * MappingGuard.java: Make both mapping guard terminating observers. + (requestAddSyscallBasedMappingObserver): New function. + (requestAddMappingObserver): Become private, take extra argument + to implement the above new function. + (requestAddMappingObserver): New proxy function. + * Ftrace.java: Request syscall based observer if user wants -m. + +2008-03-10 Petr Machata + + * Ftrace.java: Handle -m without -sym/-plt/-dyn. + 2008-03-03 Andrew Cagney * TestLtrace.java: Use frysk.config. diff --git a/frysk-core/frysk/ftrace/Ftrace.java b/frysk-core/frysk/ftrace/Ftrace.java index 6d49d03..545ecb9 100644 --- a/frysk-core/frysk/ftrace/Ftrace.java +++ b/frysk-core/frysk/ftrace/Ftrace.java @@ -252,8 +252,16 @@ public class Ftrace observationRequested(task); if (ftraceController != null || traceMmapUnmap) { - MappingGuard.requestAddMappingObserver - (task, new MyMappingObserver(ftraceController)); + MyMappingObserver o = new MyMappingObserver(ftraceController); + + // Presumably the user would like to see mappings and + // unmappings as precisely as possible, and all of them. + // Use syscall-based observer in that case. + if (traceMmapUnmap) + MappingGuard.requestAddSyscallBasedMappingObserver(task, o); + else + MappingGuard.requestAddMappingObserver(task, o); + observationRequested(task); } @@ -644,10 +652,15 @@ public class Ftrace return (TracePointWorkingSet)drivers.get(mapping.path); } + private boolean processMappedPart(MemoryMapping.Part part) { + // Ignore non-executable mappings. + // Ignore mappedPart messages if we don't trace symbols. + return part.permExecute && this.tracingController != null; + } + public Action updateMappedPart(Task task, MemoryMapping mapping, MemoryMapping.Part part) { - // Ignore non-executable mappings. - if (!part.permExecute) + if (!processMappedPart(part)) return Action.CONTINUE; TracePointWorkingSet driver = getDriver(task, mapping); @@ -666,8 +679,7 @@ public class Ftrace public Action updateUnmappedPart(Task task, MemoryMapping mapping, MemoryMapping.Part part) { - // Ignore non-executable unmappings. - if (!part.permExecute) + if (!processMappedPart(part)) return Action.CONTINUE; TracePointWorkingSet driver = getDriver(task, mapping); diff --git a/frysk-core/frysk/ftrace/MappingGuard.java b/frysk-core/frysk/ftrace/MappingGuard.java index 222132e..bcbd896 100644 --- a/frysk-core/frysk/ftrace/MappingGuard.java +++ b/frysk-core/frysk/ftrace/MappingGuard.java @@ -65,7 +65,8 @@ class MappingGuard private static final Map guardsForTask = new HashMap(); private static abstract class MappingGuardB - implements TaskObserver + implements TaskObserver, + TaskObserver.Terminating { private final Map observers = new HashMap(); // HashMap protected final Task task; @@ -110,6 +111,7 @@ class MappingGuard protected MappingGuardB(Task task) { this.task = task; + task.requestAddTerminatingObserver(this); } public synchronized void addedTo (final Object observable) @@ -162,6 +164,12 @@ class MappingGuard } } + public Action updateTerminating(Task task, Signal signal, int value) { + logger.log(Level.FINE, "The task is terminating."); + updateMapping(task, true); + return Action.CONTINUE; + } + private void updateMappedPart(final Task task, final MemoryMapping mapping, @@ -319,15 +327,13 @@ class MappingGuard private static class DebugStateMappingGuard extends MappingGuardB - implements TaskObserver.Code, - TaskObserver.Terminating + implements TaskObserver.Code { private long address; public DebugStateMappingGuard(Task task, long address) { super(task); this.address = address; task.requestAddCodeObserver(this, address); - task.requestAddTerminatingObserver(this); } public Action updateHit (Task task, long address) @@ -337,12 +343,6 @@ class MappingGuard return Action.CONTINUE; } - public Action updateTerminating(Task task, Signal signal, int value) { - logger.log(Level.FINE, "The task is terminating."); - updateMapping(task, true); - return Action.CONTINUE; - } - public void remove() { task.requestDeleteCodeObserver(this, address); } @@ -428,15 +428,21 @@ class MappingGuard return new DebugStateMappingGuard(task, fin); } - public static void requestAddMappingObserver(Task task, MappingObserver observer) { + private static void requestAddMappingObserver(Task task, MappingObserver observer, + boolean preferDebugstate) { MappingGuardB guard; synchronized (MappingGuard.class) { guard = (MappingGuardB)guardsForTask.get(task); if (guard == null) { - if (enableDebugstateObserver) + // Admitedly this is ugly, but I don't think it pays + // off to invent some fancy OO way of doing the same + // when we have just two guard types in hand. + if (enableDebugstateObserver && preferDebugstate) guard = setupDebugStateObserver(task); if (guard == null && enableSyscallObserver) guard = new SyscallMappingGuard(task); + if (guard == null && enableSyscallObserver && !preferDebugstate) + guard = setupDebugStateObserver(task); if (guard != null) guardsForTask.put(task, guard); @@ -447,6 +453,14 @@ class MappingGuard guard.addObserver(observer); } + public static void requestAddMappingObserver(Task task, MappingObserver observer) { + requestAddMappingObserver(task, observer, true); + } + + public static void requestAddSyscallBasedMappingObserver(Task task, MappingObserver observer) { + requestAddMappingObserver(task, observer, false); + } + public static void requestDeleteMappingObserver(Task task, MappingObserver observer) { MappingGuardB guard; synchronized (MappingGuard.class) { hooks/post-receive -- frysk system monitor/debugger