From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 9598 invoked by alias); 3 Jan 2008 02:28:18 -0000 Received: (qmail 9568 invoked by uid 367); 3 Jan 2008 02:28:16 -0000 Date: Thu, 03 Jan 2008 02:28:00 -0000 Message-ID: <20080103022816.9553.qmail@sourceware.org> From: cagney@sourceware.org To: frysk-cvs@sourceware.org Subject: [SCM] master: Ignore bogus requestAdd's. X-Git-Refname: refs/heads/master X-Git-Reftype: branch X-Git-Oldrev: 669debac6ae033d83a046cfdc8f93876b24da1cf X-Git-Newrev: b20d1b8ac6c297e412316e42ff53cb49f52284e4 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/msg00006.txt.bz2 The branch, master has been updated via b20d1b8ac6c297e412316e42ff53cb49f52284e4 (commit) via 7d85fc11b1bbca7e6dedad4d1c8f177f5dda58fe (commit) from 669debac6ae033d83a046cfdc8f93876b24da1cf (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email. - Log ----------------------------------------------------------------- commit b20d1b8ac6c297e412316e42ff53cb49f52284e4 Author: Andrew Cagney Date: Wed Jan 2 21:27:08 2008 -0500 Ignore bogus requestAdd's. frysk-core/frysk/proc/dead/ChangeLog 2008-01-02 Andrew Cagney * DeadTask.java (requestUnblock, requestAddClonedObserver) (requestAddForkedObserver, requestAddTerminatedObserver): Ignore requests. commit 7d85fc11b1bbca7e6dedad4d1c8f177f5dda58fe Author: Andrew Cagney Date: Wed Jan 2 20:54:07 2008 -0500 Eliminate state from DeadTask. frysk-core/frysk/proc/dead/ChangeLog 2008-01-02 Andrew Cagney * DeadTask.java (oldState, newState): Delete. (getState()): Delete; replace with exception. (oldState()): Delete; replace with exception. ----------------------------------------------------------------------- Summary of changes: frysk-core/frysk/proc/dead/ChangeLog | 8 ++ frysk-core/frysk/proc/dead/DeadTask.java | 126 ++++++++++-------------------- 2 files changed, 48 insertions(+), 86 deletions(-) First 500 lines of diff: diff --git a/frysk-core/frysk/proc/dead/ChangeLog b/frysk-core/frysk/proc/dead/ChangeLog index 71907c3..0124cdb 100644 --- a/frysk-core/frysk/proc/dead/ChangeLog +++ b/frysk-core/frysk/proc/dead/ChangeLog @@ -1,5 +1,13 @@ 2008-01-02 Andrew Cagney + * DeadTask.java (requestUnblock, requestAddClonedObserver) + (requestAddForkedObserver, requestAddTerminatedObserver): Ignore + requests. + + * DeadTask.java (oldState, newState): Delete. + (getState()): Delete; replace with exception. + (oldState()): Delete; replace with exception. + * DeadProc.java (setStateFIXME(ProcState)): Delete. * LinuxProc.java (getInitialState(boolean)): Delete. * LinuxExeProc.java (getInitialState(boolean)): Delete. diff --git a/frysk-core/frysk/proc/dead/DeadTask.java b/frysk-core/frysk/proc/dead/DeadTask.java index 76fff7d..051aac2 100644 --- a/frysk-core/frysk/proc/dead/DeadTask.java +++ b/frysk-core/frysk/proc/dead/DeadTask.java @@ -40,14 +40,12 @@ package frysk.proc.dead; import java.util.logging.Level; -import frysk.proc.Manager; import frysk.proc.Task; import frysk.proc.Proc; import frysk.proc.TaskState; import frysk.proc.TaskId; import frysk.proc.TaskObserver; import frysk.proc.TaskObservation; -import frysk.proc.TaskEvent; /** * A dead Host/Proc/Task is characterised by its lack of state, and an @@ -58,74 +56,42 @@ import frysk.proc.TaskEvent; abstract class DeadTask extends Task { DeadTask(Proc proc, TaskId taskId, TaskState initialState) { super(proc, taskId, initialState); - newState = initialState; } - /** - * The state of this task. During a state transition newState is - * NULL. - */ - private TaskState oldState; - private TaskState newState; - - /** - * Return the current state. - */ - protected final TaskState getState() { - if (newState != null) - return newState; - else - return oldState; - } protected String getStateFIXME() { - return getState().toString(); + return "dead"; } /** * Set the new state. */ protected final void set(TaskState 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, - * barf. XXX: Bit of a hack, but at least this prevents state - * transition code attempting a second recursive state transition. - */ - protected TaskState oldState() { - if (newState == null) - throw new RuntimeException(this + " double state transition"); - oldState = newState; - newState = null; - return oldState; + // ignore } /** * (Internal) Add the specified observer to the observable. */ protected void handleAddObservation(TaskObservation observation) { - newState = oldState().handleAddObservation(this, observation); + throw new RuntimeException("oops!"); } /** * (Internal) Delete the specified observer from the observable. */ protected void handleDeleteObservation(TaskObservation observation) { - newState = oldState().handleDeleteObservation(this, observation); + throw new RuntimeException("oops!"); } public void handleUnblock(TaskObserver observer) { - newState = oldState().handleUnblock(this, observer); + throw new RuntimeException("oops!"); } /** * (Internal) Requesting that the task go (or resume execution). */ public void performContinue() { - newState = oldState().handleContinue(this); + throw new RuntimeException("oops!"); } /** @@ -136,7 +102,7 @@ abstract class DeadTask extends Task { * XXX: Should not be public. */ public void performRemoval() { - newState = oldState().handleRemoval(this); + throw new RuntimeException("oops!"); } /** @@ -147,7 +113,7 @@ abstract class DeadTask extends Task { * XXX: Should not be public. */ public void performAttach() { - newState = oldState().handleAttach(this); + throw new RuntimeException("oops!"); } /** @@ -157,7 +123,7 @@ abstract class DeadTask extends Task { * @param shouldRemoveObservers whether to remove the observers as well. */ public void performDetach(boolean shouldRemoveObservers) { - newState = oldState().handleDetach(this, shouldRemoveObservers); + throw new RuntimeException("oops!"); } /** @@ -166,141 +132,131 @@ abstract class DeadTask extends Task { * resumes. */ public void requestUnblock(final TaskObserver observerArg) { - logger.log(Level.FINE, "{0} requestUnblock -- observer\n", this); - Manager.eventLoop.add(new TaskEvent(this) { - final TaskObserver observer = observerArg; - protected void execute(Task task) { - task.handleUnblock(observer); - } - }); + logger.log(Level.FINE, "{0} requestUnblock is bogus\n", this); + // XXX: Fake out for now. What kind of observers would you put + // on a core file? Might need a brain dead attached state in + // this scenario for compataibility. } /** * Add a TaskObserver.Cloned observer. */ public void requestAddClonedObserver(TaskObserver.Cloned o) { - logger.log(Level.FINE, "{0} requestAddClonedObserver\n", this); - getProc().requestAddObserver(this, clonedObservers, o); + logger.log(Level.FINE, "{0} requestAddClonedObserver is bogus\n", this); + // XXX: Fake out for now. What kind of observers would you put + // on a core file? Might need a brain dead attached state in + // this scenario for compataibility. } /** * Delete a TaskObserver.Cloned observer. */ public void requestDeleteClonedObserver(TaskObserver.Cloned o) { - logger.log(Level.FINE, "{0} requestDeleteClonedObserver\n", this); - getProc().requestDeleteObserver(this, clonedObservers, o); + throw new RuntimeException("requestDeleteClonedObserver"); } /** * Add a TaskObserver.Attached observer. */ public void requestAddAttachedObserver(TaskObserver.Attached o) { - logger.log(Level.FINE, "{0} requestAddAttachedObserver\n", this); - getProc().requestAddObserver(this, attachedObservers, o); + throw new RuntimeException("requestAddAttachedObserver"); } /** * Delete a TaskObserver.Attached observer. */ public void requestDeleteAttachedObserver(TaskObserver.Attached o) { - logger.log(Level.FINE, "{0} requestDeleteAttachedObserver\n", this); - getProc().requestDeleteObserver(this, attachedObservers, o); + throw new RuntimeException("requestDeleteAttachedObserver"); } /** * Add a TaskObserver.Forked observer. */ public void requestAddForkedObserver(TaskObserver.Forked o) { - logger.log(Level.FINE, "{0} requestAddForkedObserver\n", this); - getProc().requestAddObserver(this, forkedObservers, o); + logger.log(Level.FINE, "{0} requestAddForkedObserver is bogus\n", this); + // XXX: Fake out for now. What kind of observers would you put + // on a core file? Might need a brain dead attached state in + // this scenario for compataibility. } /** * Delete a TaskObserver.Forked observer. */ public void requestDeleteForkedObserver(TaskObserver.Forked o) { - logger.log(Level.FINE, "{0} requestDeleteForkedObserver\n", this); - getProc().requestDeleteObserver(this, forkedObservers, o); + throw new RuntimeException("requestDeleteForkedObserver"); } /** * Add a TaskObserver.Terminated observer. */ public void requestAddTerminatedObserver(TaskObserver.Terminated o) { - logger.log(Level.FINE, "{0} requestAddTerminatedObserver\n", this); - getProc().requestAddObserver(this, terminatedObservers, o); + logger.log(Level.FINE, "{0} requestAddTerminatedObserver is bogus\n", this); + // XXX: Fake out for now. What kind of observers would you put + // on a core file? Might need a brain dead attached state in + // this scenario for compataibility. } /** * Delete a TaskObserver.Terminated observer. */ public void requestDeleteTerminatedObserver(TaskObserver.Terminated o) { - logger.log(Level.FINE, "{0} requestDeleteTerminatedObserver\n", this); - getProc().requestDeleteObserver(this, terminatedObservers, o); + throw new RuntimeException("requestDeleteTerminatedObserver"); } /** * Add TaskObserver.Terminating to the TaskObserver pool. */ public void requestAddTerminatingObserver(TaskObserver.Terminating o) { - logger.log(Level.FINE, "{0} requestAddTerminatingObserver\n", this); - getProc().requestAddObserver(this, terminatingObservers, o); + throw new RuntimeException("requestAddTerminatingObserver"); } /** * Delete TaskObserver.Terminating. */ public void requestDeleteTerminatingObserver(TaskObserver.Terminating o) { - logger.log(Level.FINE, "{0} requestDeleteTerminatingObserver\n", this); - getProc().requestDeleteObserver(this, terminatingObservers, o); + throw new RuntimeException("requestDeleteTerminatingObserver"); } /** * Add TaskObserver.Execed to the TaskObserver pool. */ public void requestAddExecedObserver(TaskObserver.Execed o) { - logger.log(Level.FINE, "{0} requestAddExecedObserver\n", this); - getProc().requestAddObserver(this, execedObservers, o); + throw new RuntimeException("requestAddExecedObserver"); } /** * Delete TaskObserver.Execed. */ public void requestDeleteExecedObserver(TaskObserver.Execed o) { - logger.log(Level.FINE, "{0} requestDeleteExecedObserver\n", this); - getProc().requestDeleteObserver(this, execedObservers, o); + throw new RuntimeException("requestDeleteExecedObserver"); } /** * Add TaskObserver.Syscalls to the TaskObserver pool. */ public void requestAddSyscallsObserver(TaskObserver.Syscalls o) { - logger.log(Level.FINE, "{0} requestAddSyscallObserver\n", this); - getProc().requestAddSyscallObserver(this, syscallObservers, o); + throw new RuntimeException("requestAddSyscallsObserver"); } /** * Delete TaskObserver.Syscall. */ public void requestDeleteSyscallsObserver(TaskObserver.Syscalls o) { - logger.log(Level.FINE, "{0} requestDeleteSyscallObserver\n", this); - getProc().requestDeleteSyscallObserver(this, syscallObservers, o); + throw new RuntimeException("requestDeleteSyscallsObserver"); } /** * Add TaskObserver.Signaled to the TaskObserver pool. */ public void requestAddSignaledObserver(TaskObserver.Signaled o) { - logger.log(Level.FINE, "{0} requestAddSignaledObserver\n", this); - getProc().requestAddObserver(this, signaledObservers, o); + throw new RuntimeException("requestAddSignaledObserver"); } /** * Delete TaskObserver.Signaled. */ public void requestDeleteSignaledObserver(TaskObserver.Signaled o) { - logger.log(Level.FINE, "{0} requestDeleteSignaledObserver\n", this); - getProc().requestDeleteObserver(this, signaledObservers, o); + throw new RuntimeException("requestDeleteSignaledObserver"); } @@ -308,15 +264,13 @@ abstract class DeadTask extends Task { * Add TaskObserver.Code to the TaskObserver pool. */ public void requestAddCodeObserver(TaskObserver.Code o, long a) { - logger.log(Level.FINE, "{0} requestAddCodeObserver\n", this); - getProc().requestAddCodeObserver(this, codeObservers, o, a); + throw new RuntimeException("requestAddCodeObserver"); } /** * Delete TaskObserver.Code for the TaskObserver pool. */ public void requestDeleteCodeObserver(TaskObserver.Code o, long a) { - logger.log(Level.FINE, "{0} requestDeleteCodeObserver\n", this); - getProc().requestDeleteCodeObserver(this, codeObservers, o, a); + throw new RuntimeException("requestDeleteCodeObserver"); } } hooks/post-receive -- frysk system monitor/debugger