This is the mail archive of the
frysk-cvs@sources.redhat.com
mailing list for the frysk project.
[SCM] master: Re-indent LinuxPtraceTaskState.java.
- From: cagney at sourceware dot org
- To: frysk-cvs at sourceware dot org
- Date: 23 Jan 2008 02:29:16 -0000
- Subject: [SCM] master: Re-indent LinuxPtraceTaskState.java.
- Reply-to: frysk at sourceware dot org
The branch, master has been updated
via 6de8b43dc07e0bae95d88c2ef141bfa610579faf (commit)
via f7eb286278efc117197b3cab533830531bf655a8 (commit)
via 4e593b2936bdca786c2f9d692e5e4b069eb9610c (commit)
from c2200af0df9b4b598a92a1fa29bff2ea33b37525 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email.
- Log -----------------------------------------------------------------
commit 6de8b43dc07e0bae95d88c2ef141bfa610579faf
Author: Andrew Cagney <cagney@redhat.com>
Date: Tue Jan 22 21:09:29 2008 -0500
Re-indent LinuxPtraceTaskState.java.
frysk-core/frysk/proc/live/ChangeLog
2008-01-22 Andrew Cagney <cagney@redhat.com>
* LinuxPtraceTaskState.java: Re-indent.
commit f7eb286278efc117197b3cab533830531bf655a8
Author: Andrew Cagney <cagney@redhat.com>
Date: Tue Jan 22 20:48:22 2008 -0500
Initial pass at simplifying combined signal/trap/stop handlers.
frysk-core/frysk/proc/live/ChangeLog
2008-01-22 Andrew Cagney <cagney@redhat.com>
* LinuxPtraceTaskState.java (handleTrappedEvent(LinuxPtraceTask))
(handleSignaledEvent(LinuxPtraceTask,Signal)): Delete.
(handleStoppedEvent(LinuxPtraceTask,Signal)): Delete.
(blockOrDetach(LinuxPtraceTask)): Delete.
(blockOrAttach(LinuxPtraceTask)): Delete.
(blockOrAttachContinue(LinuxPtraceTask)): Delete.
(attemptContinue(LinuxPtraceTask)): Delete.
commit 4e593b2936bdca786c2f9d692e5e4b069eb9610c
Author: Andrew Cagney <cagney@redhat.com>
Date: Tue Jan 22 20:08:05 2008 -0500
Combine trapped, stopped, and signaled events (simplistic pass).
frysk-core/frysk/proc/live/ChangeLog
2008-01-22 Andrew Cagney <cagney@redhat.com>
* LinuxPtraceTaskState.java (handleStoppedEvent(LinuxPtraceTask,
Signal)): Replace handleStoppedEvent(LinuxPtraceTask).
* LinuxPtraceTask.java (processSignaledEvent(Signal)): Delete.
(processTrappedEvent()): Delete.
(processStoppedEvent(Signal)): Replace processStoppedEvent().
-----------------------------------------------------------------------
Summary of changes:
frysk-core/frysk/proc/live/ChangeLog | 16 +
frysk-core/frysk/proc/live/LinuxPtraceTask.java | 22 +-
.../frysk/proc/live/LinuxPtraceTaskState.java | 1419 +++++++++-----------
frysk-core/frysk/proc/live/LinuxWaitBuilder.java | 7 +-
4 files changed, 672 insertions(+), 792 deletions(-)
First 500 lines of diff:
diff --git a/frysk-core/frysk/proc/live/ChangeLog b/frysk-core/frysk/proc/live/ChangeLog
index 25c8241..38fc3a6 100644
--- a/frysk-core/frysk/proc/live/ChangeLog
+++ b/frysk-core/frysk/proc/live/ChangeLog
@@ -1,5 +1,21 @@
2008-01-22 Andrew Cagney <cagney@redhat.com>
+ * LinuxPtraceTaskState.java: Re-indent.
+
+ * LinuxPtraceTaskState.java (handleTrappedEvent(LinuxPtraceTask))
+ (handleSignaledEvent(LinuxPtraceTask,Signal)): Delete.
+ (handleStoppedEvent(LinuxPtraceTask,Signal)): Delete.
+ (blockOrDetach(LinuxPtraceTask)): Delete.
+ (blockOrAttach(LinuxPtraceTask)): Delete.
+ (blockOrAttachContinue(LinuxPtraceTask)): Delete.
+ (attemptContinue(LinuxPtraceTask)): Delete.
+
+ * LinuxPtraceTaskState.java (handleStoppedEvent(LinuxPtraceTask,
+ Signal)): Replace handleStoppedEvent(LinuxPtraceTask).
+ * LinuxPtraceTask.java (processSignaledEvent(Signal)): Delete.
+ (processTrappedEvent()): Delete.
+ (processStoppedEvent(Signal)): Replace processStoppedEvent().
+
* LinuxPtraceTask.java (sendContinue(Signal)): Replace
sendContinue(int).
(sendSyscallContinue(Signal)): Replace sendSyscallContinue(int).
diff --git a/frysk-core/frysk/proc/live/LinuxPtraceTask.java b/frysk-core/frysk/proc/live/LinuxPtraceTask.java
index 3b10fea..963ecca 100644
--- a/frysk-core/frysk/proc/live/LinuxPtraceTask.java
+++ b/frysk-core/frysk/proc/live/LinuxPtraceTask.java
@@ -189,24 +189,12 @@ public class LinuxPtraceTask extends LiveTask {
set(oldState().handleForkedEvent(this, (LinuxPtraceTask)fork));
}
/**
- * (internal) This task stopped.
+ * (internal) This task stopped with SIGNAL pending.
*/
- void processStoppedEvent ()
- {
- set(oldState().handleStoppedEvent(this));
- }
- /**
- * (internal) This task encountered a trap.
- */
- void processTrappedEvent ()
- {
- set(oldState().handleTrappedEvent(this));
- }
- /**
- * (internal) This task received a signal.
- */
- void processSignaledEvent(Signal sig) {
- set(oldState().handleSignaledEvent(this, sig));
+ void processStoppedEvent(Signal signal) {
+ logger.log(Level.FINE, "{0} stoppedEvent {1}",
+ new Object[] { this, signal });
+ set(oldState().handleStoppedEvent(this, signal));
}
/**
* (internal) The task is in the process of terminating. If SIGNAL
diff --git a/frysk-core/frysk/proc/live/LinuxPtraceTaskState.java b/frysk-core/frysk/proc/live/LinuxPtraceTaskState.java
index 7e47b2c..5f0b39a 100644
--- a/frysk-core/frysk/proc/live/LinuxPtraceTaskState.java
+++ b/frysk-core/frysk/proc/live/LinuxPtraceTaskState.java
@@ -58,23 +58,17 @@ class LinuxPtraceTaskState extends State {
super(state);
}
- LinuxPtraceTaskState handleSignaledEvent(LinuxPtraceTask task,
- Signal sig) {
- throw unhandled (task, "handleSignaledEvent");
- }
- LinuxPtraceTaskState handleStoppedEvent(LinuxPtraceTask task) {
- throw unhandled (task, "handleStoppedEvent");
- }
- LinuxPtraceTaskState handleTrappedEvent(LinuxPtraceTask task) {
- throw unhandled (task, "handleTrappedEvent");
+ LinuxPtraceTaskState handleStoppedEvent(LinuxPtraceTask task,
+ Signal signal) {
+ throw unhandled(task, "handleStoppedEvent " + signal);
}
LinuxPtraceTaskState handleSyscalledEvent(LinuxPtraceTask task) {
- throw unhandled (task, "handleSyscalledEvent");
+ throw unhandled(task, "handleSyscalledEvent");
}
LinuxPtraceTaskState handleTerminatedEvent(LinuxPtraceTask task,
Signal signal,
int status) {
- throw unhandled (task, "handleTerminatedEvent");
+ throw unhandled(task, "handleTerminatedEvent");
}
LinuxPtraceTaskState handleTerminatingEvent(LinuxPtraceTask task,
Signal signal,
@@ -122,15 +116,13 @@ class LinuxPtraceTaskState extends State {
/**
* Return the initial state of a detached task.
*/
- static LinuxPtraceTaskState detachedState ()
- {
+ static LinuxPtraceTaskState detachedState() {
return detached;
}
/**
* Return the initial state of the Main task.
*/
- static LinuxPtraceTaskState mainState ()
- {
+ static LinuxPtraceTaskState mainState() {
return StartMainTask.wantToDetach;
}
/**
@@ -145,8 +137,8 @@ class LinuxPtraceTaskState extends State {
|| parentState == inSyscallRunning)
return StartClonedTask.waitForStop;
- throw new RuntimeException ("clone's parent in unexpected state "
- + parentState);
+ throw new RuntimeException("clone's parent in unexpected state "
+ + parentState);
}
/**
@@ -161,18 +153,18 @@ class LinuxPtraceTaskState extends State {
* XXX: GCJ botches the code gen for a call to this method, from
* an anonymous inner class, when this method isn't static.
*/
- protected static void handleAttachedTerminated (LinuxPtraceTask task,
- Signal signal,
- int status) {
+ private static void handleAttachedTerminated(LinuxPtraceTask task,
+ Signal signal,
+ int status) {
logger.log(Level.FINE, "{0} handleAttachedTerminated\n", task);
if (signal != null)
task.notifyTerminated(true, signal.intValue());
else
task.notifyTerminated(false, status);
// A process with no tasks is dead ...?
- if (task.getProc().taskPool.size () == 0) {
- task.getProc().parent.remove (task.getProc());
- task.getProc().getHost().remove (task.getProc());
+ if (task.getProc().taskPool.size() == 0) {
+ task.getProc().parent.remove(task.getProc());
+ task.getProc().getHost().remove(task.getProc());
}
}
@@ -180,50 +172,50 @@ class LinuxPtraceTaskState extends State {
* The task isn't attached (it was presumably detected using a
* probe of the system process list).
*/
- protected static final LinuxPtraceTaskState detached = new LinuxPtraceTaskState("detached")
- {
- LinuxPtraceTaskState handleRemoval (LinuxPtraceTask task)
- {
- logger.log (Level.FINE, "{0} handleRemoval\n", task);
- return destroyed;
- }
- LinuxPtraceTaskState handleAttach(LinuxPtraceTask task) {
- logger.log (Level.FINE, "{0} handleAttach\n", task);
- task.sendAttach ();
- if (task.getProc().getMainTask() == task
- && Status.isStopped(task.getTid())) {
- // The attach has been initiated on the main task
- // of the process; the process state should
- // transition to (T) TRACED. If it is instead (T)
- // STOPPED then the process is stuck (suspended),
- // send it a SIGSTOP to unwedge it. /proc/status
- // is used as that differentiates between STOPPED
- // an TRACED.
- logger.log(Level.FINE,
- "{0} wake the suspended process", task);
- Signal.CONT.tkill(task.getTid());
- return new Attaching(true);
- } else {
- return new Attaching(false);
+ private static final LinuxPtraceTaskState detached
+ = new LinuxPtraceTaskState("detached") {
+ LinuxPtraceTaskState handleRemoval(LinuxPtraceTask task) {
+ logger.log(Level.FINE, "{0} handleRemoval\n", task);
+ return destroyed;
}
- }
- };
+ LinuxPtraceTaskState handleAttach(LinuxPtraceTask task) {
+ logger.log(Level.FINE, "{0} handleAttach\n", task);
+ task.sendAttach();
+ if (task.getProc().getMainTask() == task
+ && Status.isStopped(task.getTid())) {
+ // The attach has been initiated on the main task
+ // of the process; the process state should
+ // transition to (T) TRACED. If it is instead (T)
+ // STOPPED then the process is stuck (suspended),
+ // send it a SIGSTOP to unwedge it. /proc/status
+ // is used as that differentiates between STOPPED
+ // an TRACED.
+ logger.log(Level.FINE,
+ "{0} wake the suspended process", task);
+ Signal.CONT.tkill(task.getTid());
+ return new Attaching(true);
+ } else {
+ return new Attaching(false);
+ }
+ }
+ };
/**
* The task is in the process of being attached.
*/
- static private class Attaching extends LinuxPtraceTaskState {
+ private static class Attaching extends LinuxPtraceTaskState {
private final boolean waitForSIGCONT;
Attaching(boolean waitForSIGCONT) {
super("attaching");
this.waitForSIGCONT = waitForSIGCONT;
}
private SignalSet sigset = new SignalSet();
- private LinuxPtraceTaskState transitionToAttached(LinuxPtraceTask task,
- Signal signal) {
+ LinuxPtraceTaskState handleStoppedEvent(LinuxPtraceTask task,
+ Signal signal) {
if (waitForSIGCONT && signal != Signal.CONT) {
// Save the signal and then re-wait for, hopefully,
- // the SIGCONT behind it.
+ // the SIGCONT behind it. XXX: This could pass back a
+ // SIGTRAP, is that reasonable?
sigset.add(signal);
task.sendContinue(Signal.NONE);
return this;
@@ -236,51 +228,39 @@ class LinuxPtraceTaskState extends State {
new Object[] { this, sigs[i] });
sigs[i].tkill(task.getTid());
}
+ // And convert the CONT back into a STOP.
signal = Signal.STOP;
- } else if (signal == Signal.STOP) {
- // toss the stop.
+ } else if (signal == Signal.STOP || signal == Signal.TRAP) {
+ // Toss the stop event.
signal = Signal.NONE;
}
- ((LinuxPtraceProc)task.getProc()).performTaskAttachCompleted (task);
+ ((LinuxPtraceProc)task.getProc()).performTaskAttachCompleted(task);
return new Attached.WaitForContinueOrUnblock(signal);
}
}
- LinuxPtraceTaskState handleStoppedEvent(LinuxPtraceTask task) {
- logger.log (Level.FINE, "{0} handleStoppedEvent\n", task);
- return transitionToAttached(task, Signal.STOP);
- }
- LinuxPtraceTaskState handleSignaledEvent(LinuxPtraceTask task,
- Signal signal) {
- logger.log (Level.FINE, "{0} handleSignaledEvent, signal: {1}\n ", new Object[] {task, signal});
- return transitionToAttached(task, signal);
- }
- LinuxPtraceTaskState handleTrappedEvent(LinuxPtraceTask task) {
- logger.log (Level.FINE, "{0} handleTrappedEvent\n", task);
- return transitionToAttached (task, Signal.NONE);
- }
LinuxPtraceTaskState handleDisappearedEvent(LinuxPtraceTask task,
Throwable w) {
- logger.log (Level.FINE, "{0} handleDisappearedEvent\n", task);
+ logger.log(Level.FINE, "{0} handleDisappearedEvent\n", task);
// Ouch, the task disappeared before the attach reached
// it, just abandon this one (but ack the operation
// regardless).
- ((LinuxPtraceProc)task.getProc()).performTaskAttachCompleted (task);
- ((LinuxPtraceProc)task.getProc()).remove (task);
+ ((LinuxPtraceProc)task.getProc()).performTaskAttachCompleted(task);
+ ((LinuxPtraceProc)task.getProc()).remove(task);
return destroyed;
}
LinuxPtraceTaskState handleTerminatedEvent(LinuxPtraceTask task,
boolean signal, int value) {
- logger.log (Level.FINE, "{0} processTerminatedEvent\n", task);
+ logger.log(Level.FINE, "{0} processTerminatedEvent\n", task);
// Ouch, the task terminated before the attach reached it,
// just abandon this one (but ack the operation
// regardless).
- ((LinuxPtraceProc)task.getProc()).performTaskAttachCompleted (task);
- ((LinuxPtraceProc)task.getProc()).remove (task);
+ ((LinuxPtraceProc)task.getProc()).performTaskAttachCompleted(task);
+ ((LinuxPtraceProc)task.getProc()).remove(task);
return destroyed;
}
LinuxPtraceTaskState handleDetach(LinuxPtraceTask task,
boolean shouldRemoveObservers) {
- logger.log (Level.FINE, "{0} handleDetach\n", task);
+ logger.log(Level.FINE, "{0} handleDetach\n", task);
return detaching;
}
/**
@@ -291,7 +271,7 @@ class LinuxPtraceTaskState extends State {
*/
LinuxPtraceTaskState handleUnblock(LinuxPtraceTask task,
TaskObserver observer) {
- logger.log (Level.FINE, "{0} handleUnblock\n", task);
+ logger.log(Level.FINE, "{0} handleUnblock\n", task);
// Sanity check
if (task.blockers.remove(observer)) {
throw new RuntimeException
@@ -306,7 +286,7 @@ class LinuxPtraceTaskState extends State {
*/
LinuxPtraceTaskState handleAddObservation(LinuxPtraceTask task,
TaskObservation observation) {
- logger.log (Level.FINE, "{0} handleAddObservation\n", task);
+ logger.log(Level.FINE, "{0} handleAddObservation\n", task);
observation.add();
return this;
}
@@ -314,9 +294,8 @@ class LinuxPtraceTaskState extends State {
* Deleting an observer is always allowd in attaching state.
*/
LinuxPtraceTaskState handleDeleteObservation(LinuxPtraceTask task,
- TaskObservation observation)
- {
- logger.log (Level.FINE, "{0} handleDeleteObservation\n", task);
+ TaskObservation observation) {
+ logger.log(Level.FINE, "{0} handleDeleteObservation\n", task);
observation.delete();
return handleUnblock(task, observation.getTaskObserver());
}
@@ -329,16 +308,15 @@ class LinuxPtraceTaskState extends State {
* transitioned into the attached state.
*/
private static class Attached extends LinuxPtraceTaskState {
- private Attached (String name)
- {
- super ("Attached." + name);
+ private Attached(String name) {
+ super("Attached." + name);
}
/**
* In all Attached states, addObservation is allowed.
*/
- LinuxPtraceTaskState handleAddObservation(LinuxPtraceTask task, TaskObservation observation)
- {
- logger.log (Level.FINE, "{0} handleAddObservation\n", task);
+ LinuxPtraceTaskState handleAddObservation(LinuxPtraceTask task,
+ TaskObservation observation) {
+ logger.log(Level.FINE, "{0} handleAddObservation\n", task);
observation.add();
return this;
}
@@ -346,9 +324,8 @@ class LinuxPtraceTaskState extends State {
* In all Attached states, deleteObservation is allowed.
*/
LinuxPtraceTaskState handleDeleteObservation(LinuxPtraceTask task,
- TaskObservation observation)
- {
- logger.log (Level.FINE, "{0} handleDeleteObservation\n", task);
+ TaskObservation observation) {
+ logger.log(Level.FINE, "{0} handleDeleteObservation\n", task);
observation.delete();
return handleUnblock(task, observation.getTaskObserver());
}
@@ -356,11 +333,11 @@ class LinuxPtraceTaskState extends State {
/**
* While attaching the LinuxPtraceTask disappeared, go to destroyed.
*/
- LinuxPtraceTaskState handleTerminatedEvent (LinuxPtraceTask task,
- Signal signal,
- int status) {
+ LinuxPtraceTaskState handleTerminatedEvent(LinuxPtraceTask task,
+ Signal signal,
+ int status) {
logger.log(Level.FINE, "{0} handleTerminatedEvent\n", task);
- ((LinuxPtraceProc)task.getProc()).remove (task);
+ ((LinuxPtraceProc)task.getProc()).remove(task);
handleAttachedTerminated(task, signal, status);
return destroyed;
}
@@ -372,7 +349,7 @@ class LinuxPtraceTaskState extends State {
static LinuxPtraceTaskState transitionToRunningState(LinuxPtraceTask task, Signal signal) {
logger.log(Level.FINE, "transitionToRunningState\n");
task.sendSetOptions();
- if (task.notifyAttached () > 0)
+ if (task.notifyAttached() > 0)
return new BlockedSignal(signal, false);
else
return running.sendContinue(task, signal);
@@ -384,19 +361,18 @@ class LinuxPtraceTaskState extends State {
private static class WaitForContinueOrUnblock extends Attached {
private final Signal signal;
WaitForContinueOrUnblock(Signal signal) {
- super ("WaitForContinueOrUnblock");
+ super("WaitForContinueOrUnblock");
this.signal = signal;
}
- LinuxPtraceTaskState handleUnblock (LinuxPtraceTask task,
- TaskObserver observer)
- {
- logger.log (Level.FINE, "{0} handleUnblock\n", task);
- task.blockers.remove (observer);
+ LinuxPtraceTaskState handleUnblock(LinuxPtraceTask task,
+ TaskObserver observer) {
+ logger.log(Level.FINE, "{0} handleUnblock\n", task);
+ task.blockers.remove(observer);
return this;
}
- LinuxPtraceTaskState handleContinue (LinuxPtraceTask task) {
- logger.log (Level.FINE, "{0} handleContinue\n", task);
- if (task.blockers.size () == 0)
+ LinuxPtraceTaskState handleContinue(LinuxPtraceTask task) {
+ logger.log(Level.FINE, "{0} handleContinue\n", task);
+ if (task.blockers.size() == 0)
return transitionToRunningState(task, signal);
else
return new Attached.WaitForUnblock(signal);
@@ -411,34 +387,33 @@ class LinuxPtraceTaskState extends State {
private static class WaitForUnblock extends Attached {
private final Signal signal;
WaitForUnblock(Signal signal) {
- super ("WaitForUnblock");
+ super("WaitForUnblock");
this.signal = signal;
}
- public String toString () {
- return super.toString () + ",signal=" + signal;
+ public String toString() {
+ return super.toString() + ",signal=" + signal;
}
- LinuxPtraceTaskState handleUnblock (LinuxPtraceTask task,
- TaskObserver observer)
- {
- logger.log (Level.FINE, "{0} handleUnblock\n", task);
+ LinuxPtraceTaskState handleUnblock(LinuxPtraceTask task,
+ TaskObserver observer) {
+ logger.log(Level.FINE, "{0} handleUnblock\n", task);
logger.logp(Level.FINEST, "Attached.WaitForUnblock",
"handleUnblock", "{0} blockers",
new Integer(task.blockers.size()));
- task.blockers.remove (observer);
- if (task.blockers.size () == 0)
+ task.blockers.remove(observer);
+ if (task.blockers.size() == 0)
return transitionToRunningState(task, signal);
return this;
}
- LinuxPtraceTaskState handleDetach (LinuxPtraceTask task, boolean shouldRemoveObservers)
- {
+ LinuxPtraceTaskState handleDetach(LinuxPtraceTask task,
+ boolean shouldRemoveObservers) {
- logger.log (Level.FINE, "{0} handleDetach\n", task);
+ logger.log(Level.FINE, "{0} handleDetach\n", task);
if (shouldRemoveObservers)
task.removeObservers();
// XXX: Otherwise check that observers are empty?
task.sendDetach(signal);
- ((LinuxPtraceProc)task.getProc()).performTaskDetachCompleted (task);
+ ((LinuxPtraceProc)task.getProc()).performTaskDetachCompleted(task);
return detached;
}
}
@@ -458,10 +433,9 @@ class LinuxPtraceTaskState extends State {
* assumption to that the task should be attached and proceed on
* that basis.
*/
- static class StartMainTask extends LinuxPtraceTaskState {
- StartMainTask (String name)
- {
- super ("StartMainTask." + name);
+ private static class StartMainTask extends LinuxPtraceTaskState {
+ StartMainTask(String name) {
+ super("StartMainTask." + name);
}
/**
* StartMainTask out assuming that, once the process has
@@ -469,31 +443,23 @@ class LinuxPtraceTaskState extends State {
* all blocks have been removed, a detach should occure.
*/
static final LinuxPtraceTaskState wantToDetach =
- new StartMainTask ("wantToDetach")
- {
- LinuxPtraceTaskState handleAttach (LinuxPtraceTask task)
- {
- logger.log (Level.FINE, "{0} handleAttach\n", task);
- ((LinuxPtraceProc)task.getProc()).performTaskAttachCompleted (task);
+ new StartMainTask("wantToDetach") {
+ LinuxPtraceTaskState handleAttach(LinuxPtraceTask task) {
+ logger.log(Level.FINE, "{0} handleAttach\n", task);
+ ((LinuxPtraceProc)task.getProc()).performTaskAttachCompleted(task);
return StartMainTask.wantToAttach;
}
- private LinuxPtraceTaskState blockOrDetach (LinuxPtraceTask task)
- {
- if (task.notifyForkedOffspring () > 0)
- return StartMainTask.detachBlocked;
- task.sendDetach(Signal.NONE);
- ((LinuxPtraceProc)task.getProc()).performTaskDetachCompleted (task);
- return detached;
- }
- LinuxPtraceTaskState handleTrappedEvent (LinuxPtraceTask task)
- {
- logger.log (Level.FINE, "{0} handleTrappedEvent\n", task);
- return blockOrDetach (task);
- }
- LinuxPtraceTaskState handleStoppedEvent (LinuxPtraceTask task)
hooks/post-receive
--
frysk system monitor/debugger