frysk.proc.live
Class LinuxPtraceTaskState

java.lang.Object
  frysk.proc.live.State
      frysk.proc.live.LinuxPtraceTaskState

Direct Known Subclasses:

LinuxPtraceTaskState.Attached, LinuxPtraceTaskState.Attaching, LinuxPtraceTaskState.BlockedSignal, LinuxPtraceTaskState.Running, LinuxPtraceTaskState.StartClonedTask, LinuxPtraceTaskState.StartMainTask

abstract class LinuxPtraceTaskState
extends State

A Linux Task's State tracked using PTRACE.

Nested Class Summary

private static class	LinuxPtraceTaskState.Attached The task is attached, and waiting to be either continued, or unblocked.
private static class	LinuxPtraceTaskState.Attaching The task is in the process of being attached.
private static class	LinuxPtraceTaskState.BlockedSignal The LinuxPtraceTask is blocked by a set of observers, remain in this state until all the observers have unblocked themselves.
private static class	LinuxPtraceTaskState.Running Keep the task running.
(package private) static class	LinuxPtraceTaskState.StartClonedTask A cloned task just starting out, wait for it to stop, and for it to be unblocked.
private static class	LinuxPtraceTaskState.StartMainTask A new main Task, created via fork, just starting.
private static class	LinuxPtraceTaskState.Stepping
private static class	LinuxPtraceTaskState.SyscallBlockedInSyscall A task blocked after SyscallEnter notification or while runningInSyscall by an event other than syscalledEvent

Field Summary

private static LinuxPtraceTaskState	blockedContinue The task is in the blocked state with no pending signal.
private static LinuxPtraceTaskState	blockedInExecSyscall A task recieves an execedEvent and the client decides to block the task -> this state.
private static LinuxPtraceTaskState	destroyed
private static LinuxPtraceTaskState	detached The task isn't attached (it was presumably detected using a probe of the system process list).
protected static LinuxPtraceTaskState	detaching
private static Log	fine
protected static LinuxPtraceTaskState.Running	inSyscallRunning
protected static LinuxPtraceTaskState.Running	running Sharable instance of the running state.
(package private) static LinuxPtraceTaskState.Stepping	stepping
private static LinuxPtraceTaskState	syscallBlockedInSyscallContinue A shareable instance of SyscallBlockedInSyscall where the signal to be delivered is 0.
private static Log	warning

Constructor Summary

LinuxPtraceTaskState(String state)

Method Summary

(package private) static LinuxPtraceTaskState	clonedState(LinuxPtraceTaskState parentState) Return the initial state of a cloned task.
(package private) static LinuxPtraceTaskState	detachedState() Return the initial state of a detached task.
(package private) LinuxPtraceTaskState	handleAddObservation(LinuxPtraceTask task, TaskObservation observation)
(package private) LinuxPtraceTaskState	handleAttach(LinuxPtraceTask task)
private static void	handleAttachedTerminated(LinuxPtraceTask task, Signal signal, int status) An attached task was destroyed, notify observers and, when the containing process has no tasks left, assume its also exited so should be destroyed.
(package private) LinuxPtraceTaskState	handleClonedEvent(LinuxPtraceTask task, LinuxPtraceTask clone)
(package private) LinuxPtraceTaskState	handleContinue(LinuxPtraceTask task)
(package private) LinuxPtraceTaskState	handleDeleteObservation(LinuxPtraceTask task, TaskObservation observation)
(package private) LinuxPtraceTaskState	handleDetach(LinuxPtraceTask task, boolean shouldRemoveObservers)
(package private) LinuxPtraceTaskState	handleExecedEvent(LinuxPtraceTask task)
(package private) LinuxPtraceTaskState	handleForkedEvent(LinuxPtraceTask task, LinuxPtraceTask fork)
(package private) LinuxPtraceTaskState	handleRemoval(LinuxPtraceTask task)
(package private) LinuxPtraceTaskState	handleStoppedEvent(LinuxPtraceTask task, Signal signal)
(package private) LinuxPtraceTaskState	handleSyscalledEvent(LinuxPtraceTask task)
(package private) abstract LinuxPtraceTaskState	handleTerminatedEvent(LinuxPtraceTask task, Signal signal, int status) The process was terminated (can happen at any time and hence must always be handled).
(package private) LinuxPtraceTaskState	handleTerminatingEvent(LinuxPtraceTask task, Signal signal, int status)
(package private) LinuxPtraceTaskState	handleUnblock(LinuxPtraceTask task, TaskObserver observer)
(package private) static LinuxPtraceTaskState	mainState() Return the initial state of the Main task.

Methods inherited from class frysk.proc.live.State

toString, unhandled, unhandled

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

fine

private static final Log fine

warning

private static final Log warning

detached

private static final LinuxPtraceTaskState detached

The task isn't attached (it was presumably detected using a probe of the system process list).

stepping

static final LinuxPtraceTaskState.Stepping stepping

running

protected static final LinuxPtraceTaskState.Running running

Sharable instance of the running state.

inSyscallRunning

protected static final LinuxPtraceTaskState.Running inSyscallRunning

detaching

protected static final LinuxPtraceTaskState detaching

blockedContinue

private static final LinuxPtraceTaskState blockedContinue

The task is in the blocked state with no pending signal. It is a common case that a task is blocked with no pending signal so this instance can be shared.

syscallBlockedInSyscallContinue

private static final LinuxPtraceTaskState syscallBlockedInSyscallContinue

A shareable instance of SyscallBlockedInSyscall where the signal to be delivered is 0.

blockedInExecSyscall

private static final LinuxPtraceTaskState blockedInExecSyscall

A task recieves an execedEvent and the client decides to block the task -> this state. This state is needed because if in this state the client desides to switch over to syscall tacing mode the next event is expected to be a syscall event representing the exec syscall exit not entry. so if the switch to syscall tracing mode occurs the correct state (runningInSyscall) is returned

destroyed

private static final LinuxPtraceTaskState destroyed

Constructor Detail

LinuxPtraceTaskState

LinuxPtraceTaskState(String state)

Method Detail

handleStoppedEvent

LinuxPtraceTaskState handleStoppedEvent(LinuxPtraceTask task,
                                        Signal signal)

handleSyscalledEvent

LinuxPtraceTaskState handleSyscalledEvent(LinuxPtraceTask task)

handleTerminatedEvent

abstract LinuxPtraceTaskState handleTerminatedEvent(LinuxPtraceTask task,
                                                    Signal signal,
                                                    int status)

The process was terminated (can happen at any time and hence must always be handled).

handleTerminatingEvent

LinuxPtraceTaskState handleTerminatingEvent(LinuxPtraceTask task,
                                            Signal signal,
                                            int status)

handleExecedEvent

LinuxPtraceTaskState handleExecedEvent(LinuxPtraceTask task)

handleContinue

LinuxPtraceTaskState handleContinue(LinuxPtraceTask task)

handleRemoval

LinuxPtraceTaskState handleRemoval(LinuxPtraceTask task)

handleAttach

LinuxPtraceTaskState handleAttach(LinuxPtraceTask task)

handleDetach

LinuxPtraceTaskState handleDetach(LinuxPtraceTask task,
                                  boolean shouldRemoveObservers)

handleClonedEvent

LinuxPtraceTaskState handleClonedEvent(LinuxPtraceTask task,
                                       LinuxPtraceTask clone)

handleForkedEvent

LinuxPtraceTaskState handleForkedEvent(LinuxPtraceTask task,
                                       LinuxPtraceTask fork)

handleUnblock

LinuxPtraceTaskState handleUnblock(LinuxPtraceTask task,
                                   TaskObserver observer)

handleAddObservation

LinuxPtraceTaskState handleAddObservation(LinuxPtraceTask task,
                                          TaskObservation observation)

handleDeleteObservation

LinuxPtraceTaskState handleDeleteObservation(LinuxPtraceTask task,
                                             TaskObservation observation)

detachedState

static LinuxPtraceTaskState detachedState()

Return the initial state of a detached task.

mainState

static LinuxPtraceTaskState mainState()

Return the initial state of the Main task.

clonedState

static LinuxPtraceTaskState clonedState(LinuxPtraceTaskState parentState)

Return the initial state of a cloned task.

handleAttachedTerminated

private static void handleAttachedTerminated(LinuxPtraceTask task,
                                             Signal signal,
                                             int status)

An attached task was destroyed, notify observers and, when the containing process has no tasks left, assume its also exited so should be destroyed. XXX: Linux doesn't provide a way for detecting the transition from "process with no tasks" (aka zombie or defunct) to destroyed. This code unfortunatly bypasses the zombied state. XXX: GCJ botches the code gen for a call to this method, from an anonymous inner class, when this method isn't static.