public inbox for frysk-cvs@sourceware.org
help / color / mirror / Atom feed
From: cagney@sourceware.org
To: frysk-cvs@sourceware.org
Subject: [SCM] master: Push Signal, instead of int sig, into LinuxPtraceTaskState.
Date: Tue, 22 Jan 2008 19:20:00 -0000 [thread overview]
Message-ID: <20080122192038.17855.qmail@sourceware.org> (raw)
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
reply other threads:[~2008-01-22 19:20 UTC|newest]
Thread overview: [no followups] expand[flat|nested] mbox.gz Atom feed
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20080122192038.17855.qmail@sourceware.org \
--to=cagney@sourceware.org \
--cc=frysk-cvs@sourceware.org \
--cc=frysk@sourceware.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
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).