This is the mail archive of the
frysk@sources.redhat.com
mailing list for the frysk project.
Remove duplicated syscalltracing tracking from TaskState
- From: Mark Wielaard <mark at klomp dot org>
- To: frysk at sourceware dot org
- Date: Thu, 05 Oct 2006 14:53:46 +0200
- Subject: Remove duplicated syscalltracing tracking from TaskState
Hi,
While on the train I went through TaskState again to remove some of the
duplicated tracking of syscalltracing. We can deduce that information
from the syscallObservers installed on the Task. So there is no reason
to duplicate logic to track that inside the TaskState machine. The
problem with tracking the info also in a TaskState field is that it
might get out of sync with the actual state of the Task syscallObservers
field if we are not careful. The patch also adds
handleDeleteSyscallObserver() to a couple of states that didn't handle
that operation yet. And it gets rid of one extra state,
syscallBlockedContinue.
2006-10-05 Mark Wielaard <mark@klomp.org>
* TaskState.java (transitionToRunningState): Remove syscalltracing
argument, use task.syscallObservers.numberOfObservers().
(WaitForContinueOrUnblock.syscallObserverAdded): Remove field.
(WaitForUnblock.syscallObserverAdded): Likewise.
(StartClonedTask.syscallObserverAdded): Likewise.
(BlockedSignal.syscallObserverAdded): Likewise.
(syscallBlockedContinue): Removed.
Tested on x86 and x86_64.
There is still similar logic in the Running states. But there at least
the flag is final so those TaskStates aren't mutable.
Committed,
Mark
Index: frysk-core/frysk/proc/TaskState.java
===================================================================
RCS file: /cvs/frysk/frysk-core/frysk/proc/TaskState.java,v
retrieving revision 1.117
diff -u -r1.117 TaskState.java
--- frysk-core/frysk/proc/TaskState.java 29 Sep 2006 16:47:24 -0000 1.117
+++ frysk-core/frysk/proc/TaskState.java 5 Oct 2006 08:54:53 -0000
@@ -312,14 +314,13 @@
* Once the task is both unblocked and continued, should
* transition to the running state.
*/
- static TaskState transitionToRunningState(Task task, int signal,
- boolean syscalltracing)
+ static TaskState transitionToRunningState(Task task, int signal)
{
logger.log(Level.FINE, "transitionToRunningState\n");
task.sendSetOptions();
if (task.notifyAttached () > 0)
- return new BlockedSignal(signal, syscalltracing, false);
- if (syscalltracing)
+ return new BlockedSignal(signal, false);
+ if (task.syscallObservers.numberOfObservers() > 0)
{
task.sendSyscallContinue(signal);
return syscallRunning;
@@ -337,8 +338,6 @@
private static class WaitForContinueOrUnblock
extends Attached
{
- boolean syscallObserverAdded;
-
final int signal;
WaitForContinueOrUnblock (int signal)
{
@@ -356,19 +355,29 @@
{
logger.log (Level.FINE, "{0} handleContinue\n", task);
if (task.blockers.size () == 0)
- return transitionToRunningState(task, signal,
- syscallObserverAdded);
+ return transitionToRunningState(task, signal);
else
return new Attached.WaitForUnblock (signal);
}
TaskState handleAddSyscallObserver (Task task, Observable observable, Observer observer)
{
logger.log (Level.FINE, "{0} handleAddSyscallObserver\n", task);
- task.startTracingSyscalls();
+ if (task.syscallObservers.numberOfObservers() == 0)
+ task.startTracingSyscalls();
observable.add(observer);
- syscallObserverAdded = true;
return this;
}
+ TaskState handleDeleteSyscallObserver(Task task,
+ Observable observable,
+ Observer observer)
+ {
+ logger.log (Level.FINE, "{0} handleDeleteSyscallObserver\n", task);
+ observable.delete(observer);
+ if (task.syscallObservers.numberOfObservers() == 0)
+ task.stopTracingSyscalls();
+ return this;
+ }
+
}
private static final TaskState waitForContinueOrUnblock =
new Attached.WaitForContinueOrUnblock (0);
@@ -379,10 +388,8 @@
private static class WaitForUnblock
extends Attached
{
-
- boolean syscallObserverAdded;
-
final int signal;
+
WaitForUnblock (int signal)
{
super ("WaitForUnblock");
@@ -401,8 +408,7 @@
logger.log (Level.FINE, "{0} handleUnblock\n", task);
task.blockers.remove (observer);
if (task.blockers.size () == 0)
- return transitionToRunningState(task, signal,
- syscallObserverAdded);
+ return transitionToRunningState(task, signal);
return this;
}
TaskState handleAddSyscallObserver(Task task,
@@ -411,10 +417,22 @@
{
logger.log (Level.FINE, "{0} handleAddSyscallObserver\n",
task);
+ if (task.syscallObservers.numberOfObservers() == 0)
+ task.startTracingSyscalls();
observable.add(observer);
- syscallObserverAdded = true;
return this;
}
+ TaskState handleDeleteSyscallObserver(Task task,
+ Observable observable,
+ Observer observer)
+ {
+ logger.log (Level.FINE, "{0} handleDeleteSyscallObserver\n", task);
+ observable.delete(observer);
+ if (task.syscallObservers.numberOfObservers() == 0)
+ task.stopTracingSyscalls();
+ return this;
+ }
+
}
}
@@ -557,8 +575,7 @@
{
if (task.notifyForkedOffspring () > 0)
return StartMainTask.attachContinueBlocked;
- return Attached.transitionToRunningState(task, signal,
- false);
+ return Attached.transitionToRunningState(task, signal);
}
TaskState handleTrappedEvent (Task task)
{
@@ -628,7 +645,7 @@
task.blockers.remove (observer);
if (task.blockers.size () > 0)
return StartMainTask.attachContinueBlocked;
- return Attached.transitionToRunningState(task, 0, false);
+ return Attached.transitionToRunningState(task, 0);
}
};
}
@@ -640,8 +657,6 @@
static class StartClonedTask
extends TaskState
{
- boolean syscallObserverAdded;
-
StartClonedTask (String name)
{
super ("StartClonedTask." + name);
@@ -709,12 +724,9 @@
// XXX: Really notify attached here?
if (task.notifyAttached () > 0)
{
- if (syscallObserverAdded)
- return syscallBlockedContinue;
- else
- return blockedContinue;
+ return blockedContinue;
}
- if (syscallObserverAdded)
+ if (task.syscallObservers.numberOfObservers() > 0)
{
task.sendSyscallContinue (0);
return syscallRunning;
@@ -730,9 +742,9 @@
Observable observable,
Observer observer)
{
- task.startTracingSyscalls();
+ if (task.syscallObservers.numberOfObservers() == 0)
+ task.startTracingSyscalls();
observable.add(observer);
- syscallObserverAdded = true;
return this;
}
}
@@ -776,14 +788,14 @@
{
if (insyscall)
return syscallBlockedInSyscallContinue;
- return syscalltracing ? syscallBlockedContinue : blockedContinue;
+ return blockedContinue;
}
TaskState handleSignaledEvent (Task task, int sig)
{
logger.log (Level.FINE, "{0} handleSignaledEvent, signal: {1}\n", new Object[] {task, new Integer(sig)});
if (task.notifySignaled (sig) > 0) {
- return new BlockedSignal(sig, syscalltracing, insyscall);
+ return new BlockedSignal(sig, insyscall);
}
else {
sendContinue(task, sig);
@@ -866,7 +878,7 @@
if(task.notifyTerminating (signal, value) > 0)
{
if (signal)
- return new BlockedSignal(value, syscalltracing, insyscall);
+ return new BlockedSignal(value, insyscall);
else
return blockedContinue();
}
@@ -1099,7 +1115,7 @@
return syscallBlockedInSyscallContinue;
if (insyscall && task.notifySyscallExit() > 0)
- return syscallBlockedContinue;
+ return blockedContinue;
task.sendSyscallContinue(0);
return insyscall ? syscallRunning : inSyscallRunningTraced;
@@ -1232,15 +1248,13 @@
private static class BlockedSignal
extends TaskState
{
- final boolean syscallObserverAdded;
+ final int sig;
final boolean insyscall;
- int sig;
- BlockedSignal(int sig, boolean syscallObserverAdded, boolean insyscall)
+ BlockedSignal(int sig, boolean insyscall)
{
super ("BlockedSignal");
this.sig = sig;
- this.syscallObserverAdded = syscallObserverAdded;
this.insyscall = insyscall;
}
public String toString ()
@@ -1260,7 +1274,7 @@
task.blockers.remove (observer);
if (task.blockers.size () > 0)
return this; // Still blocked.
- if (syscallObserverAdded)
+ if (task.syscallObservers.numberOfObservers() > 0)
{
task.sendSyscallContinue(sig);
return insyscall ? inSyscallRunningTraced : syscallRunning;
@@ -1272,20 +1286,27 @@
}
}
- TaskState handleAddSyscallObserver (Task task, Observable observable, Observer observer){
+ TaskState handleAddSyscallObserver (Task task, Observable observable,
+ Observer observer)
+ {
logger.log (Level.FINE, "{0} handleAddSyscallObserver\n", task);
- task.startTracingSyscalls();
+ if (task.syscallObservers.numberOfObservers() == 0)
+ task.startTracingSyscalls();
observable.add(observer);
- if (sig == 0)
- return (insyscall
- ? syscallBlockedInSyscallContinue
- : syscallBlockedContinue);
- else if (insyscall)
- return new SyscallBlockedInSyscall(sig);
- else
- return new BlockedSignal(sig, true, false);
+ return this;
}
+ TaskState handleDeleteSyscallObserver(Task task,
+ Observable observable,
+ Observer observer)
+ {
+ logger.log (Level.FINE, "{0} handleDeleteSyscallObserver\n", task);
+ observable.delete(observer);
+ if (task.syscallObservers.numberOfObservers() == 0)
+ task.stopTracingSyscalls();
+ return this;
+ }
+
TaskState handleAddCodeObserver(Task task, Observable observable,
TaskObserver.Code observer,
long address)
@@ -1319,7 +1340,7 @@
* signal so this instance can be shared.
*/
private static final TaskState blockedContinue =
- new BlockedSignal(0, false, false)
+ new BlockedSignal(0, false)
{
public String toString ()
{
@@ -1328,25 +1349,13 @@
};
/**
- * Sharable instance of the common blockedContinue in syscall tracing mode
- */
- private static final TaskState syscallBlockedContinue =
- new BlockedSignal(0, true, false)
- {
- public String toString ()
- {
- return "syscallBlockedContinue";
- }
- };
-
- /**
* A task blocked after SyscallEnter notification or while runningInSyscall
* by an event other than syscalledEvent
*/
public static class SyscallBlockedInSyscall extends BlockedSignal{
SyscallBlockedInSyscall(int sig)
{
- super(sig, true, true);
+ super(sig, true);
}
public String toString ()
@@ -1375,7 +1384,7 @@
* (runningInSyscall) is returned
*/
private static final TaskState blockedInExecSyscall =
- new BlockedSignal(0, false, true)
+ new BlockedSignal(0, true)
{
public String toString ()
{