public inbox for frysk-cvs@sourceware.org
help / color / mirror / Atom feed
* [SCM] master: Push Signal, instead of int sig, into LinuxPtraceTaskState.
@ 2008-01-22 19:20 cagney
0 siblings, 0 replies; only message in thread
From: cagney @ 2008-01-22 19:20 UTC (permalink / raw)
To: frysk-cvs
The branch, master has been updated
via 005eb511bce81b206a973829ea98f430ce021684 (commit)
from a99507d78618aa744a397a231de9646d506f7394 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email.
- Log -----------------------------------------------------------------
commit 005eb511bce81b206a973829ea98f430ce021684
Author: Andrew Cagney <cagney@redhat.com>
Date: Tue Jan 22 14:19:59 2008 -0500
Push Signal, instead of int sig, into LinuxPtraceTaskState.
frysk-core/frysk/proc/live/ChangeLog
2008-01-22 Andrew Cagney <cagney@redhat.com>
* LinuxPtraceTask.java (processSignaledEvent(Signal)): Replace
processSignaledEvent(int).
(processTerminatingEvent(Signal,int)): Replace
processTerminatingEvent(boolean,int).
(processTerminatedEvent(Signal,int)): Replace
processTerminatedEvent(Signal,int).
* LinuxPtraceTaskState.java: Update.
* LinuxWaitBuilder.java: Update.
-----------------------------------------------------------------------
Summary of changes:
frysk-core/frysk/proc/live/ChangeLog | 9 +
frysk-core/frysk/proc/live/LinuxPtraceTask.java | 18 +-
.../frysk/proc/live/LinuxPtraceTaskState.java | 322 ++++++++++----------
frysk-core/frysk/proc/live/LinuxWaitBuilder.java | 10 +-
4 files changed, 175 insertions(+), 184 deletions(-)
First 500 lines of diff:
diff --git a/frysk-core/frysk/proc/live/ChangeLog b/frysk-core/frysk/proc/live/ChangeLog
index 093b9f2..c847d5d 100644
--- a/frysk-core/frysk/proc/live/ChangeLog
+++ b/frysk-core/frysk/proc/live/ChangeLog
@@ -1,5 +1,14 @@
2008-01-22 Andrew Cagney <cagney@redhat.com>
+ * LinuxPtraceTask.java (processSignaledEvent(Signal)): Replace
+ processSignaledEvent(int).
+ (processTerminatingEvent(Signal,int)): Replace
+ processTerminatingEvent(boolean,int).
+ (processTerminatedEvent(Signal,int)): Replace
+ processTerminatedEvent(Signal,int).
+ * LinuxPtraceTaskState.java: Update.
+ * LinuxWaitBuilder.java: Update.
+
* LinuxWaitBuilder.java: Update to match
WaitBuilder.exitEvent(int,Signal,int,boolean) and
WaitBuilder.terminated(int,Signal,int,boolean).
diff --git a/frysk-core/frysk/proc/live/LinuxPtraceTask.java b/frysk-core/frysk/proc/live/LinuxPtraceTask.java
index 1d4633b..e22646b 100644
--- a/frysk-core/frysk/proc/live/LinuxPtraceTask.java
+++ b/frysk-core/frysk/proc/live/LinuxPtraceTask.java
@@ -205,16 +205,15 @@ public class LinuxPtraceTask extends LiveTask {
/**
* (internal) This task received a signal.
*/
- void processSignaledEvent (int sig)
- {
+ void processSignaledEvent(Signal sig) {
set(oldState().handleSignaledEvent(this, sig));
}
/**
- * (internal) The task is in the process of terminating. If SIGNAL, VALUE is
- * the signal, otherwize it is the exit status.
+ * (internal) The task is in the process of terminating. If SIGNAL
+ * is non-ZERO the terminating signal, else STATUS is the exit
+ * status.
*/
- void processTerminatingEvent (boolean signal, int value)
- {
+ void processTerminatingEvent(Signal signal, int value) {
set(oldState().handleTerminatingEvent(this, signal, value));
}
/**
@@ -233,11 +232,10 @@ public class LinuxPtraceTask extends LiveTask {
set(oldState().handleSyscalledEvent(this));
}
/**
- * (internal) The task has terminated; if SIGNAL, VALUE is the signal,
- * otherwize it is the exit status.
+ * (internal) The task has terminated; if SIGNAL is non-NULL the
+ * termination signal else STATUS contains the exit status.
*/
- void processTerminatedEvent (boolean signal, int value)
- {
+ void processTerminatedEvent(Signal signal, int value) {
set(oldState().handleTerminatedEvent(this, signal, value));
}
/**
diff --git a/frysk-core/frysk/proc/live/LinuxPtraceTaskState.java b/frysk-core/frysk/proc/live/LinuxPtraceTaskState.java
index fe0eecc..f19b6ca 100644
--- a/frysk-core/frysk/proc/live/LinuxPtraceTaskState.java
+++ b/frysk-core/frysk/proc/live/LinuxPtraceTaskState.java
@@ -58,7 +58,8 @@ class LinuxPtraceTaskState extends State {
super(state);
}
- LinuxPtraceTaskState handleSignaledEvent(LinuxPtraceTask task, int sig) {
+ LinuxPtraceTaskState handleSignaledEvent(LinuxPtraceTask task,
+ Signal sig) {
throw unhandled (task, "handleSignaledEvent");
}
LinuxPtraceTaskState handleStoppedEvent(LinuxPtraceTask task) {
@@ -71,13 +72,13 @@ class LinuxPtraceTaskState extends State {
throw unhandled (task, "handleSyscalledEvent");
}
LinuxPtraceTaskState handleTerminatedEvent(LinuxPtraceTask task,
- boolean signal,
- int value) {
+ Signal signal,
+ int status) {
throw unhandled (task, "handleTerminatedEvent");
}
LinuxPtraceTaskState handleTerminatingEvent(LinuxPtraceTask task,
- boolean signal,
- int value) {
+ Signal signal,
+ int status) {
throw unhandled(task, "handleTerminatingEvent");
}
LinuxPtraceTaskState handleExecedEvent(LinuxPtraceTask task) {
@@ -160,11 +161,14 @@ 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, boolean signal,
- int value)
- {
- logger.log (Level.FINE, "{0} handleAttachedTerminated\n", task);
- task.notifyTerminated (signal, value);
+ protected 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());
@@ -216,11 +220,11 @@ class LinuxPtraceTaskState extends State {
}
private SignalSet sigset = new SignalSet();
private LinuxPtraceTaskState transitionToAttached(LinuxPtraceTask task,
- int signal) {
- if (waitForSIGCONT && !Signal.CONT.equals(signal)) {
+ Signal signal) {
+ if (waitForSIGCONT && signal != Signal.CONT) {
// Save the signal and then re-wait for, hopefully,
// the SIGCONT behind it.
- sigset.add(Signal.valueOf(signal));
+ sigset.add(signal);
task.sendContinue(0);
return this;
} else {
@@ -232,27 +236,27 @@ class LinuxPtraceTaskState extends State {
new Object[] { this, sigs[i] });
sigs[i].tkill(task.getTid());
}
- signal = Signal.STOP.intValue();
- } else if (Signal.STOP.equals(signal)) {
+ signal = Signal.STOP;
+ } else if (signal == Signal.STOP) {
// toss the stop.
- signal = 0;
+ signal = Signal.NONE;
}
((LinuxPtraceProc)task.getProc()).performTaskAttachCompleted (task);
- return new Attached.WaitForContinueOrUnblock (signal);
+ return new Attached.WaitForContinueOrUnblock(signal);
}
}
LinuxPtraceTaskState handleStoppedEvent(LinuxPtraceTask task) {
logger.log (Level.FINE, "{0} handleStoppedEvent\n", task);
- return transitionToAttached(task, Signal.STOP.intValue());
+ return transitionToAttached(task, Signal.STOP);
}
LinuxPtraceTaskState handleSignaledEvent(LinuxPtraceTask task,
- int signal) {
- logger.log (Level.FINE, "{0} handleSignaledEvent, signal: {1}\n ", new Object[] {task,new Integer(signal)});
+ 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, 0);
+ return transitionToAttached (task, Signal.NONE);
}
LinuxPtraceTaskState handleDisappearedEvent(LinuxPtraceTask task,
Throwable w) {
@@ -352,36 +356,34 @@ class LinuxPtraceTaskState extends State {
/**
* While attaching the LinuxPtraceTask disappeared, go to destroyed.
*/
- LinuxPtraceTaskState handleTerminatedEvent (LinuxPtraceTask task, boolean signal,
- int value)
- {
- logger.log (Level.FINE, "{0} handleTerminatedEvent\n", task);
- ((LinuxPtraceProc)task.getProc()).remove (task);
- handleAttachedTerminated (task, signal, value);
- return destroyed;
+ LinuxPtraceTaskState handleTerminatedEvent (LinuxPtraceTask task,
+ Signal signal,
+ int status) {
+ logger.log(Level.FINE, "{0} handleTerminatedEvent\n", task);
+ ((LinuxPtraceProc)task.getProc()).remove (task);
+ handleAttachedTerminated(task, signal, status);
+ return destroyed;
}
/**
* Once the task is both unblocked and continued, should
* transition to the running state.
*/
- static LinuxPtraceTaskState transitionToRunningState(LinuxPtraceTask task, int signal)
- {
+ static LinuxPtraceTaskState transitionToRunningState(LinuxPtraceTask task, Signal signal) {
logger.log(Level.FINE, "transitionToRunningState\n");
task.sendSetOptions();
if (task.notifyAttached () > 0)
return new BlockedSignal(signal, false);
-
- return running.sendContinue(task, signal);
+ else
+ return running.sendContinue(task, signal);
}
/**
* The blocked task has stopped, possibly with a pending
* signal, waiting on either a continue or an unblock.
*/
private static class WaitForContinueOrUnblock extends Attached {
- final int signal;
- WaitForContinueOrUnblock (int signal)
- {
+ private final Signal signal;
+ WaitForContinueOrUnblock(Signal signal) {
super ("WaitForContinueOrUnblock");
this.signal = signal;
}
@@ -392,35 +394,28 @@ class LinuxPtraceTaskState extends State {
task.blockers.remove (observer);
return this;
}
- LinuxPtraceTaskState handleContinue (LinuxPtraceTask task)
- {
+ 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);
+ return new Attached.WaitForUnblock(signal);
}
}
private static final LinuxPtraceTaskState waitForContinueOrUnblock =
- new Attached.WaitForContinueOrUnblock (0);
+ new Attached.WaitForContinueOrUnblock(Signal.NONE);
/**
* Got continue, just need to clear the blocks.
*/
private static class WaitForUnblock extends Attached {
- final int signal;
-
- WaitForUnblock (int signal)
- {
+ private final Signal signal;
+ WaitForUnblock(Signal signal) {
super ("WaitForUnblock");
this.signal = signal;
}
- public String toString ()
- {
- if (signal == 0)
- return super.toString ();
- else
- return super.toString () + ",signal=" + signal;
+ public String toString () {
+ return super.toString () + ",signal=" + signal;
}
LinuxPtraceTaskState handleUnblock (LinuxPtraceTask task,
TaskObserver observer)
@@ -442,7 +437,7 @@ class LinuxPtraceTaskState extends State {
if (shouldRemoveObservers)
task.removeObservers();
// XXX: Otherwise check that observers are empty?
- task.sendDetach(signal);
+ task.sendDetach(signal.intValue());
((LinuxPtraceProc)task.getProc()).performTaskDetachCompleted (task);
return detached;
}
@@ -579,32 +574,30 @@ class LinuxPtraceTaskState extends State {
* The task is all ready to run, but still waiting for it to
* stop so that it can be properly attached.
*/
- static final LinuxPtraceTaskState wantToAttachContinue =
- new StartMainTask ("wantToAttachContinue")
- {
+ private static final LinuxPtraceTaskState wantToAttachContinue =
+ new StartMainTask ("wantToAttachContinue") {
LinuxPtraceTaskState blockOrAttachContinue(LinuxPtraceTask task,
- int signal) {
+ Signal signal) {
// Mark this LinuxPtraceTask as just started.
// See Running.handleTrapped for more explanation.
task.justStartedXXX = true;
- if (task.notifyForkedOffspring () > 0)
+ if (task.notifyForkedOffspring() > 0)
return StartMainTask.attachContinueBlocked;
- return Attached.transitionToRunningState(task, signal);
+ else
+ return Attached.transitionToRunningState(task, signal);
}
- LinuxPtraceTaskState handleTrappedEvent (LinuxPtraceTask task)
- {
- logger.log (Level.FINE, "{0} handleTrappedEvent\n", task);
- return blockOrAttachContinue (task, 0);
+ LinuxPtraceTaskState handleTrappedEvent (LinuxPtraceTask task) {
+ logger.log(Level.FINE, "{0} handleTrappedEvent\n", task);
+ return blockOrAttachContinue(task, Signal.NONE);
}
- LinuxPtraceTaskState handleStoppedEvent (LinuxPtraceTask task)
- {
- logger.log (Level.FINE, "{0} handleStoppedEvent\n", task);
- return blockOrAttachContinue (task, 0);
+ LinuxPtraceTaskState handleStoppedEvent (LinuxPtraceTask task) {
+ logger.log(Level.FINE, "{0} handleStoppedEvent\n", task);
+ return blockOrAttachContinue(task, Signal.NONE);
}
- LinuxPtraceTaskState handleSignaledEvent (LinuxPtraceTask task, int signal)
- {
- logger.log (Level.FINE, "{0} handleSignaledEvent\n", task);
- return blockOrAttachContinue (task, signal);
+ LinuxPtraceTaskState handleSignaledEvent(LinuxPtraceTask task,
+ Signal signal) {
+ logger.log(Level.FINE, "{0} handleSignaledEvent\n", task);
+ return blockOrAttachContinue(task, signal);
}
// Adding or removing observers doesn't impact this state.
@@ -675,7 +668,7 @@ class LinuxPtraceTaskState extends State {
task.blockers.remove (observer);
if (task.blockers.size () > 0)
return StartMainTask.attachContinueBlocked;
- return Attached.transitionToRunningState(task, 0);
+ return Attached.transitionToRunningState(task, Signal.NONE);
}
};
}
@@ -698,7 +691,7 @@ class LinuxPtraceTaskState extends State {
// XXX: Really notify attached here?
if (task.notifyAttached () > 0)
return blockedContinue;
- return running.sendContinue(task, 0);
+ return running.sendContinue(task, Signal.NONE);
}
LinuxPtraceTaskState handleAddObservation(LinuxPtraceTask task, TaskObservation observation)
{
@@ -754,7 +747,7 @@ class LinuxPtraceTaskState extends State {
{
return blockedContinue;
}
- return running.sendContinue(task, 0);
+ return running.sendContinue(task, Signal.NONE);
}
};
}
@@ -799,8 +792,7 @@ class LinuxPtraceTaskState extends State {
* breakpoints, with or without syscall tracing.
* Returns the new Running (sub) state of the Task.
*/
- Running sendContinue(LinuxPtraceTask task, int sig)
- {
+ Running sendContinue(LinuxPtraceTask task, Signal sig) {
Breakpoint bp = task.steppingBreakpoint;
logger.log (Level.FINE, "{0} sendContinue, {1}\n",
new Object[] { task, bp });
@@ -828,30 +820,24 @@ class LinuxPtraceTaskState extends State {
// Step when there is a breakpoint at the current location
// or there are Instruction observers installed.
if (bp != null
- || task.instructionObservers.numberOfObservers() > 0)
- {
- task.sendStepInstruction(sig);
+ || task.instructionObservers.numberOfObservers() > 0) {
+ task.sendStepInstruction(sig.intValue());
return stepping;
- }
- else
- {
+ } else {
// Always reset this, only the first step is important.
// See Running.handleTrapped() for more.
task.justStartedXXX = false;
- if (task.syscallObservers.numberOfObservers() > 0)
- {
- task.sendSyscallContinue(sig);
+ if (task.syscallObservers.numberOfObservers() > 0) {
+ task.sendSyscallContinue(sig.intValue());
return this;
- }
- else
- {
- task.sendContinue(sig);
+ } else {
+ task.sendContinue(sig.intValue());
// If we were stepping, but no breakpoint step or instruction
// observers are installed we are running again.
return (this != stepping) ? this : running;
- }
- }
+ }
+ }
}
/**
@@ -865,14 +851,13 @@ class LinuxPtraceTaskState extends State {
return blockedContinue;
}
- LinuxPtraceTaskState handleSignaledEvent (LinuxPtraceTask task, int sig)
- {
- logger.log (Level.FINE, "{0} handleSignaledEvent, signal: {1}\n", new Object[] {task, new Integer(sig)});
- if (task.notifySignaled (sig) > 0) {
+ LinuxPtraceTaskState handleSignaledEvent(LinuxPtraceTask task,
+ Signal sig) {
+ logger.log (Level.FINE, "{0} handleSignaledEvent, signal: {1}\n", new Object[] {task, sig});
+ if (task.notifySignaled(sig.intValue()) > 0)
return new BlockedSignal(sig, insyscall);
- }
else
- return sendContinue(task, sig);
+ return sendContinue(task, sig);
}
LinuxPtraceTaskState handleStoppedEvent (LinuxPtraceTask task)
{
@@ -904,32 +889,34 @@ class LinuxPtraceTaskState extends State {
else
newState = insyscall ? inSyscallRunning : running;
- return newState.sendContinue(task, 0);
+ return newState.sendContinue(task, Signal.NONE);
}
- LinuxPtraceTaskState handleTerminatingEvent (LinuxPtraceTask task, boolean signal,
- int value)
+ LinuxPtraceTaskState handleTerminatingEvent(LinuxPtraceTask task,
+ Signal signal,
+ int status)
{
logger.log(Level.FINE, "{0} handleTerminatingEvent\n", task);
- if (task.notifyTerminating (signal, value) > 0)
- {
- if (signal)
- return new BlockedSignal(value, insyscall);
- else
- return blockedContinue();
- }
+ if (signal != null
+ ? task.notifyTerminating (true, signal.intValue()) > 0
+ : task.notifyTerminating (false, status) > 0) {
+ if (signal != null)
+ return new BlockedSignal(signal, insyscall);
+ else
+ return blockedContinue();
+ }
- if (signal)
- return sendContinue(task, value);
+ if (signal != null)
+ return sendContinue(task, signal);
else
- return sendContinue(task, 0);
+ return sendContinue(task, Signal.NONE);
}
- LinuxPtraceTaskState handleTerminatedEvent (LinuxPtraceTask task, boolean signal,
- int value)
- {
+ LinuxPtraceTaskState handleTerminatedEvent (LinuxPtraceTask task,
+ Signal signal,
+ int status) {
logger.log (Level.FINE, "{0} handleTerminatedEvent\n", task);
((LinuxPtraceProc)task.getProc()).remove (task);
- handleAttachedTerminated (task, signal, value);
+ handleAttachedTerminated(task, signal, status);
return destroyed;
}
LinuxPtraceTaskState handleExecedEvent (LinuxPtraceTask task)
@@ -961,7 +948,7 @@ class LinuxPtraceTaskState extends State {
else
{
// XXX logic is slightly confusing after exec() call.
- sendContinue(task, 0);
+ sendContinue(task, Signal.NONE);
return inSyscallRunning;
}
}
@@ -992,14 +979,14 @@ class LinuxPtraceTaskState extends State {
logger.log (Level.FINE, "{0} handleClonedEvent\n", task);
if (task.notifyClonedParent (clone) > 0)
return blockedContinue();
- return sendContinue(task, 0);
+ return sendContinue(task, Signal.NONE);
}
LinuxPtraceTaskState handleForkedEvent (LinuxPtraceTask task, LinuxPtraceTask fork)
{
logger.log (Level.FINE, "{0} handleForkedEvent\n", task);
if (task.notifyForkedParent (fork) > 0)
return blockedContinue();
- return sendContinue(task, 0);
+ return sendContinue(task, Signal.NONE);
}
/**
@@ -1036,7 +1023,7 @@ class LinuxPtraceTaskState extends State {
{
System.err.println("Whoa! Wrong state for stepping: "
+ this);
- return sendContinue(task, 0);
+ return sendContinue(task, Signal.NONE);
}
}
else
@@ -1050,7 +1037,7 @@ class LinuxPtraceTaskState extends State {
setupSteppingBreakpoint(task, address);
hooks/post-receive
--
frysk system monitor/debugger
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2008-01-22 19:20 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2008-01-22 19:20 [SCM] master: Push Signal, instead of int sig, into LinuxPtraceTaskState 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).