public inbox for frysk-cvs@sourceware.org
help / color / mirror / Atom feed
* [SCM] master: Always handle terminated events.
@ 2008-03-18 2:47 cagney
0 siblings, 0 replies; only message in thread
From: cagney @ 2008-03-18 2:47 UTC (permalink / raw)
To: frysk-cvs
The branch, master has been updated
via dce689bb1f007f71609d223f8640332591297c8d (commit)
via 231c7e127c05d29d3f212c5dfc18f47194e46bd5 (commit)
from 0319ac322fb655df6e61faaeda18416951514f9b (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email.
- Log -----------------------------------------------------------------
commit dce689bb1f007f71609d223f8640332591297c8d
Author: Andrew Cagney <cagney@redhat.com>
Date: Mon Mar 17 22:45:05 2008 -0400
Always handle terminated events.
frysk-core/frysk/proc/ChangeLog
2008-03-17 Andrew Cagney <cagney@redhat.com>
* TestTaskObserver.java (attachDieingTask(int,boolean)): Do not
check attached count.
frysk-core/frysk/proc/live/ChangeLog
2008-03-17 Andrew Cagney <cagney@redhat.com>
* LinuxPtraceTaskState.java (getDestroyed): Delete.
(handleDisappearedEvent(LinuxPtraceTask)): Delete.
(handleTerminatedEvent(LinuxPtraceTask,Signal,int)): Make
abstract; implement in all sub-classes.
* LinuxPtraceTask.java (processClonedEvent(LinuxPtraceTask)):
Catch Errno.Esrch.
frysk-sys/frysk/rsl/ChangeLog
2008-03-17 Andrew Cagney <cagney@redhat.com>
* Log.java (log(String,Object,String,Object,String,int)): New.
commit 231c7e127c05d29d3f212c5dfc18f47194e46bd5
Author: Andrew Cagney <cagney@redhat.com>
Date: Mon Mar 17 17:46:15 2008 -0400
Delete LinuxPtraceTask.set(LinuxPtraceTaskState).
frysk-core/frysk/proc/live/ChangeLog
2008-03-17 Andrew Cagney <cagney@redhat.com>
* LinuxPtraceTask.java (set(LinuxPtraceTaskState)): Delete.
* LinuxWaitBuilder.java: Update
-----------------------------------------------------------------------
Summary of changes:
frysk-core/frysk/proc/ChangeLog | 2 +
frysk-core/frysk/proc/TestTaskObserver.java | 5 +-
frysk-core/frysk/proc/live/ChangeLog | 10 ++
frysk-core/frysk/proc/live/LinuxPtraceTask.java | 122 ++++++++++++++------
.../frysk/proc/live/LinuxPtraceTaskState.java | 107 +++++++----------
frysk-core/frysk/proc/live/LinuxWaitBuilder.java | 5 +-
frysk-sys/frysk/rsl/ChangeLog | 4 +
frysk-sys/frysk/rsl/Log.java | 5 +
8 files changed, 158 insertions(+), 102 deletions(-)
First 500 lines of diff:
diff --git a/frysk-core/frysk/proc/ChangeLog b/frysk-core/frysk/proc/ChangeLog
index 4255d71..8682b39 100644
--- a/frysk-core/frysk/proc/ChangeLog
+++ b/frysk-core/frysk/proc/ChangeLog
@@ -1,5 +1,7 @@
2008-03-17 Andrew Cagney <cagney@redhat.com>
+ * TestTaskObserver.java (attachDieingTask(int,boolean)): Do not
+ check attached count.
* Proc.java (requestRefresh()): Delete.
(sendRefresh()): Make concrete.
diff --git a/frysk-core/frysk/proc/TestTaskObserver.java b/frysk-core/frysk/proc/TestTaskObserver.java
index 18ecf2c..509b11f 100644
--- a/frysk-core/frysk/proc/TestTaskObserver.java
+++ b/frysk-core/frysk/proc/TestTaskObserver.java
@@ -316,11 +316,10 @@ public class TestTaskObserver
}
// Try to add the observer to the now defunct task. Should
- // successfully fail.
+ // fail (which will stop the event loop).
FailedObserver failedObserver = new FailedObserver ();
task.requestAddAttachedObserver (failedObserver);
- assertRunUntilStop ("fail to add observer");
- assertEquals ("added count", 1, failedObserver.addedCount());
+ assertRunUntilStop("fail to add observer");
}
/** {@link #attachDieingTask} */
public void testAttachDieingMainTask ()
diff --git a/frysk-core/frysk/proc/live/ChangeLog b/frysk-core/frysk/proc/live/ChangeLog
index 39d79f9..1680e6b 100644
--- a/frysk-core/frysk/proc/live/ChangeLog
+++ b/frysk-core/frysk/proc/live/ChangeLog
@@ -1,5 +1,15 @@
2008-03-17 Andrew Cagney <cagney@redhat.com>
+ * LinuxPtraceTaskState.java (getDestroyed): Delete.
+ (handleDisappearedEvent(LinuxPtraceTask)): Delete.
+ (handleTerminatedEvent(LinuxPtraceTask,Signal,int)): Make
+ abstract; implement in all sub-classes.
+ * LinuxPtraceTask.java (processClonedEvent(LinuxPtraceTask)):
+ Catch Errno.Esrch.
+
+ * LinuxPtraceTask.java (set(LinuxPtraceTaskState)): Delete.
+ * LinuxWaitBuilder.java: Update
+
* LinuxPtraceProcState.java (handleRefresh(LinuxPtraceProc)): Delete.
* LinuxPtraceProc.java (requestRefresh()): Delete.
diff --git a/frysk-core/frysk/proc/live/LinuxPtraceTask.java b/frysk-core/frysk/proc/live/LinuxPtraceTask.java
index fc56ef5..0c3a102 100644
--- a/frysk-core/frysk/proc/live/LinuxPtraceTask.java
+++ b/frysk-core/frysk/proc/live/LinuxPtraceTask.java
@@ -190,24 +190,34 @@ public class LinuxPtraceTask extends LiveTask {
/**
* (internal) This task cloned creating the new Task cloneArg.
*/
- void processClonedEvent (Task clone)
- {
- set(oldState().handleClonedEvent(this, (LinuxPtraceTask)clone));
+ void processClonedEvent(LinuxPtraceTask clone) {
+ try {
+ newState = oldState().handleClonedEvent(this, clone);
+ } catch (Errno.Esrch e) {
+ newState = handleDisappearedEvent(e);
+ }
}
/**
* (internal) This Task forked creating an entirely new child process
* containing one (the fork) task.
*/
- void processForkedEvent (Task fork)
- {
- set(oldState().handleForkedEvent(this, (LinuxPtraceTask)fork));
+ void processForkedEvent(LinuxPtraceTask fork) {
+ try {
+ newState = oldState().handleForkedEvent(this, fork);
+ } catch (Errno.Esrch e) {
+ newState = handleDisappearedEvent(e);
+ }
}
/**
* (internal) This task stopped with SIGNAL pending.
*/
void processStoppedEvent(Signal signal) {
- fine.log(this, "stoppedEvent", signal);
- set(oldState().handleStoppedEvent(this, signal));
+ try {
+ fine.log(this, "stoppedEvent", signal);
+ newState = oldState().handleStoppedEvent(this, signal);
+ } catch (Errno.Esrch e) {
+ newState = handleDisappearedEvent(e);
+ }
}
/**
* (internal) The task is in the process of terminating. If SIGNAL
@@ -215,36 +225,55 @@ public class LinuxPtraceTask extends LiveTask {
* status.
*/
void processTerminatingEvent(Signal signal, int value) {
- set(oldState().handleTerminatingEvent(this, signal, value));
+ try {
+ newState = oldState().handleTerminatingEvent(this, signal, value);
+ } catch (Errno.Esrch e) {
+ newState = handleDisappearedEvent(e);
+ }
}
/**
* (internal) The task has disappeared (due to an exit or some other error
* operation).
*/
- void processDisappearedEvent (Throwable arg)
- {
- set(oldState().handleDisappearedEvent(this, arg));
+ void processDisappearedEvent(Throwable arg) {
+ newState = handleDisappearedEvent(arg);
+ }
+ private LinuxPtraceTaskState handleDisappearedEvent(Throwable arg) {
+ // Don't call oldState() here; things are stuffed without also
+ // worrying about double state transitions.
+ return oldState.handleTerminatedEvent(this, Signal.KILL,
+ -Signal.KILL.intValue());
}
/**
* (internal) The task is performing a system call.
*/
- void processSyscalledEvent ()
- {
- set(oldState().handleSyscalledEvent(this));
+ void processSyscalledEvent() {
+ try {
+ newState = oldState().handleSyscalledEvent(this);
+ } catch (Errno.Esrch e) {
+ newState = handleDisappearedEvent(e);
+ }
}
/**
* (internal) The task has terminated; if SIGNAL is non-NULL the
* termination signal else STATUS contains the exit status.
*/
void processTerminatedEvent(Signal signal, int value) {
- set(oldState().handleTerminatedEvent(this, signal, value));
+ try {
+ newState = oldState().handleTerminatedEvent(this, signal, value);
+ } catch (Errno.Esrch e) {
+ newState = handleDisappearedEvent(e);
+ }
}
/**
* (internal) The task has execed, overlaying itself with another program.
*/
- void processExecedEvent ()
- {
- set(oldState().handleExecedEvent(this));
+ void processExecedEvent() {
+ try {
+ newState = oldState().handleExecedEvent(this);
+ } catch (Errno.Esrch e) {
+ newState = handleDisappearedEvent(e);
+ }
}
/**
@@ -397,13 +426,6 @@ public class LinuxPtraceTask extends LiveTask {
}
/**
- * Set the new state.
- */
- void set(LinuxPtraceTaskState newState) {
- this.newState = newState;
- }
-
- /**
* Return the current state while at the same time marking that
* the state is in flux. If a second attempt to change state
* occurs before the current state transition has completed,
@@ -422,25 +444,41 @@ public class LinuxPtraceTask extends LiveTask {
* (Internal) Add the specified observer to the observable.
*/
void handleAddObservation(TaskObservation observation) {
- newState = oldState().handleAddObservation(this, observation);
+ try {
+ newState = oldState().handleAddObservation(this, observation);
+ } catch (Errno.Esrch e) {
+ newState = handleDisappearedEvent(e);
+ }
}
/**
* (Internal) Delete the specified observer from the observable.
*/
void handleDeleteObservation(TaskObservation observation) {
- newState = oldState().handleDeleteObservation(this, observation);
+ try {
+ newState = oldState().handleDeleteObservation(this, observation);
+ } catch (Errno.Esrch e) {
+ newState = handleDisappearedEvent(e);
+ }
}
void handleUnblock(TaskObserver observer) {
- newState = oldState().handleUnblock(this, observer);
+ try {
+ newState = oldState().handleUnblock(this, observer);
+ } catch (Errno.Esrch e) {
+ newState = handleDisappearedEvent(e);
+ }
}
/**
* (Internal) Requesting that the task go (or resume execution).
*/
void performContinue() {
- newState = oldState().handleContinue(this);
+ try {
+ newState = oldState().handleContinue(this);
+ } catch (Errno.Esrch e) {
+ newState = handleDisappearedEvent(e);
+ }
}
/**
@@ -451,7 +489,11 @@ public class LinuxPtraceTask extends LiveTask {
* XXX: Should not be public.
*/
void performRemoval() {
- newState = oldState().handleRemoval(this);
+ try {
+ newState = oldState().handleRemoval(this);
+ } catch (Errno.Esrch e) {
+ newState = handleDisappearedEvent(e);
+ }
}
/**
@@ -462,7 +504,11 @@ public class LinuxPtraceTask extends LiveTask {
* XXX: Should not be public.
*/
void performAttach() {
- newState = oldState().handleAttach(this);
+ try {
+ newState = oldState().handleAttach(this);
+ } catch (Errno.Esrch e) {
+ newState = handleDisappearedEvent(e);
+ }
}
/**
@@ -472,7 +518,11 @@ public class LinuxPtraceTask extends LiveTask {
* @param shouldRemoveObservers whether to remove the observers as well.
*/
void performDetach(boolean shouldRemoveObservers) {
- newState = oldState().handleDetach(this, shouldRemoveObservers);
+ try {
+ newState = oldState().handleDetach(this, shouldRemoveObservers);
+ } catch (Errno.Esrch e) {
+ newState = handleDisappearedEvent(e);
+ }
}
/**
@@ -973,7 +1023,11 @@ public class LinuxPtraceTask extends LiveTask {
observation = new TaskObservation((LinuxPtraceTask)task, observable, observer,
watchAction, false) {
public void execute() {
- newState = oldState().handleDeleteObservation(LinuxPtraceTask.this, this);
+ try {
+ newState = oldState().handleDeleteObservation(LinuxPtraceTask.this, this);
+ } catch (Errno.Esrch e) {
+ newState = handleDisappearedEvent(e);
+ }
}
public boolean needsSuspendedAction() {
diff --git a/frysk-core/frysk/proc/live/LinuxPtraceTaskState.java b/frysk-core/frysk/proc/live/LinuxPtraceTaskState.java
index 8d800ce..07c9bd5 100644
--- a/frysk-core/frysk/proc/live/LinuxPtraceTaskState.java
+++ b/frysk-core/frysk/proc/live/LinuxPtraceTaskState.java
@@ -54,7 +54,7 @@ import frysk.rsl.LogFactory;
* A Linux Task's State tracked using PTRACE.
*/
-class LinuxPtraceTaskState extends State {
+abstract class LinuxPtraceTaskState extends State {
private static final Log fine = LogFactory.fine(LinuxPtraceTaskState.class);
private static final Log warning = LogFactory.warning(LinuxPtraceTaskState.class);
@@ -69,11 +69,13 @@ class LinuxPtraceTaskState extends State {
LinuxPtraceTaskState handleSyscalledEvent(LinuxPtraceTask task) {
throw unhandled(task, "handleSyscalledEvent");
}
- LinuxPtraceTaskState handleTerminatedEvent(LinuxPtraceTask task,
- Signal signal,
- int status) {
- throw unhandled(task, "handleTerminatedEvent");
- }
+ /**
+ * The process was terminated (can happen at any time and hence
+ * must always be handled).
+ */
+ abstract LinuxPtraceTaskState handleTerminatedEvent(LinuxPtraceTask task,
+ Signal signal,
+ int status);
LinuxPtraceTaskState handleTerminatingEvent(LinuxPtraceTask task,
Signal signal,
int status) {
@@ -82,9 +84,6 @@ class LinuxPtraceTaskState extends State {
LinuxPtraceTaskState handleExecedEvent(LinuxPtraceTask task) {
throw unhandled(task, "handleExecedEvent");
}
- LinuxPtraceTaskState handleDisappearedEvent(LinuxPtraceTask task, Throwable w) {
- throw unhandled(task, "handleDisappearedEvent");
- }
LinuxPtraceTaskState handleContinue(LinuxPtraceTask task) {
throw unhandled(task, "handleContinue");
}
@@ -177,6 +176,15 @@ class LinuxPtraceTaskState extends State {
*/
private static final LinuxPtraceTaskState detached
= new LinuxPtraceTaskState("detached") {
+ LinuxPtraceTaskState handleTerminatedEvent(LinuxPtraceTask task,
+ Signal signal,
+ int status) {
+ fine.log("handleTerminatedEvent", task,
+ "signal", signal, "status", status);
+ // Termination event for a forked, but unattached
+ // child; discard.
+ return detached;
+ }
LinuxPtraceTaskState handleRemoval(LinuxPtraceTask task) {
fine.log("handleRemoval", task);
return destroyed;
@@ -243,18 +251,8 @@ class LinuxPtraceTaskState extends State {
return new Attached.WaitForContinueOrUnblock(signal);
}
}
- LinuxPtraceTaskState handleDisappearedEvent(LinuxPtraceTask task,
- Throwable w) {
- fine.log("handleDisappearedEvent", 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()).removeTask(task);
- return destroyed;
- }
LinuxPtraceTaskState handleTerminatedEvent(LinuxPtraceTask task,
- boolean signal, int value) {
+ Signal signal, int value) {
fine.log("processTerminatedEvent", task);
// Ouch, the task terminated before the attach reached it,
// just abandon this one (but ack the operation
@@ -350,7 +348,6 @@ class LinuxPtraceTaskState extends State {
handleAttachedTerminated(task, signal, status);
return destroyed;
}
-
/**
* Once the task is both unblocked and continued, should
* transition to the running state.
@@ -427,9 +424,9 @@ class LinuxPtraceTaskState extends State {
/**
* A new main Task, created via fork, just starting. Go with the
- * assumption that it should detach. Two events exist that
+ * assumption that it should detach. Three events exist that
* influence this assumption: the task stops; and the controlling
- * proc orders an attach.
+ * proc orders an attach; the task terminated.
*
* If the LinuxPtraceTask stops then, once the ForkedOffspring
* observers have stopped blocking this, do the detach.
@@ -443,6 +440,14 @@ class LinuxPtraceTaskState extends State {
StartMainTask(String name) {
super("StartMainTask." + name);
}
+ LinuxPtraceTaskState handleTerminatedEvent(LinuxPtraceTask task,
+ Signal signal,
+ int status) {
+ fine.log("handleTerminatedEvent", task,
+ "signal", signal, "status", status);
+ handleAttachedTerminated(task, signal, status);
+ return destroyed;
+ }
/**
* StartMainTask out assuming that, once the process has
* stopped, ForkedOffspring observers have been notified, and
@@ -641,6 +646,14 @@ class LinuxPtraceTaskState extends State {
StartClonedTask(String name) {
super("StartClonedTask." + name);
}
+ LinuxPtraceTaskState handleTerminatedEvent(LinuxPtraceTask task,
+ Signal signal,
+ int status) {
+ fine.log("handleTerminatedEvent", task,
+ "signal", signal, "status", status);
+ handleAttachedTerminated(task, signal, status);
+ return destroyed;
+ }
LinuxPtraceTaskState handleAddObservation(LinuxPtraceTask task,
TaskObservation observation) {
fine.log("handleAddObservation", task);
@@ -886,10 +899,6 @@ class LinuxPtraceTaskState extends State {
return inSyscallRunning;
}
}
- LinuxPtraceTaskState handleDisappearedEvent(LinuxPtraceTask task, Throwable w) {
- fine.log("handleDisappearedEvent", task);
- return disappeared;
- }
LinuxPtraceTaskState handleContinue(LinuxPtraceTask task) {
fine.log("handleContinue", task);
return this;
@@ -1224,15 +1233,6 @@ class LinuxPtraceTaskState extends State {
((LinuxPtraceProc)task.getProc()).performTaskDetachCompleted(task);
return destroyed;
}
- LinuxPtraceTaskState handleDisappearedEvent(LinuxPtraceTask task,
- Throwable w) {
- // Woops, it disappeared before we were really detached,
- // pretend the detached happened anyway.
- fine.log("handleDisappearedEvent", task);
- ((LinuxPtraceProc)task.getProc()).removeTask(task);
- ((LinuxPtraceProc)task.getProc()).performTaskDetachCompleted(task);
- return destroyed;
- }
LinuxPtraceTaskState handleForkedEvent(LinuxPtraceTask task,
LinuxPtraceTask fork) {
fine.log("handleForkedEvent", task, "fork", fork);
@@ -1401,43 +1401,26 @@ class LinuxPtraceTaskState extends State {
}
};
- private static final LinuxPtraceTaskState disappeared
- = new LinuxPtraceTaskState("disappeared") {
+ private static final LinuxPtraceTaskState destroyed
+ = new LinuxPtraceTaskState("destroyed") {
LinuxPtraceTaskState handleTerminatedEvent(LinuxPtraceTask task,
Signal signal,
int status) {
- fine.log("handleTerminatedEvent", task);
- ((LinuxPtraceProc)task.getProc()).removeTask(task);
- handleAttachedTerminated(task, signal, status);
+ fine.log("discard handleTerminatedEvent", task,
+ "signal", signal, "status", status);
return destroyed;
}
LinuxPtraceTaskState handleTerminatingEvent(LinuxPtraceTask task,
Signal signal,
int status) {
- fine.log("handleTerminatingEvent", task);
- if (signal != null)
- task.notifyTerminating(true, signal.intValue());
- else
- task.notifyTerminating(false, status);
- return disappeared;
- }
- LinuxPtraceTaskState handleDisappearedEvent(LinuxPtraceTask task,
- Throwable w) {
- fine.log("handleDisappearedEvent", task);
- return disappeared;
+ fine.log("discard handleTerminatingEvent", task,
+ "signal", signal, "status", status);
+ return destroyed;
}
- };
-
- static LinuxPtraceTaskState getDestroyed() {
- return destroyed;
- }
-
- private static final LinuxPtraceTaskState destroyed
- = new LinuxPtraceTaskState("destroyed") {
LinuxPtraceTaskState handleAttach(LinuxPtraceTask task) {
fine.log("handleAttach", task);
- // Lie; the Proc wants to know that the operation has
- // been processed rather than the request was
+ // Lie; the Proc wants to know that the operation
+ // has been processed rather than the request was
// successful.
((LinuxPtraceProc)task.getProc()).performTaskAttachCompleted(task);
return destroyed;
diff --git a/frysk-core/frysk/proc/live/LinuxWaitBuilder.java b/frysk-core/frysk/proc/live/LinuxWaitBuilder.java
index f71d6b0..39ce518 100644
--- a/frysk-core/frysk/proc/live/LinuxWaitBuilder.java
+++ b/frysk-core/frysk/proc/live/LinuxWaitBuilder.java
@@ -47,7 +47,6 @@ import frysk.sys.WaitBuilder;
import java.util.LinkedList;
import java.util.List;
import frysk.rsl.Log;
-import frysk.proc.Task;
import frysk.sys.ProcessIdentifier;
import frysk.proc.TaskAttachedObserverXXX;
@@ -142,8 +141,8 @@ class LinuxWaitBuilder implements WaitBuilder {
// Create an attached and running fork of TASK.
LinuxPtraceProc forkedProc = new LinuxPtraceProc(forkingTask, fork);
// The forked proc's only and main task.
hooks/post-receive
--
frysk system monitor/debugger
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2008-03-18 2:47 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2008-03-18 2:47 [SCM] master: Always handle terminated events cagney
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).