Signal Handling [XL]

• getitimer(it:itimer) -> tuple(integer, integer) [XL]
• itimer <: thing [XL]
• kill(p:integer, sig:signal_handler) -> void [XL]
• raise(sig:signal_handler) -> void [XL]
• setitimer(it:itimer, interval:integer, value:integer) -> tuple(integer, integer) [XL]
• sigblock(self:subtype[signal_handler]) -> set[signal_handler] [XL]
• signal(sig:signal_handler, p:property) -> property [XL]
• signal_handler <: thing [XL]
• sigpending() -> set[signal_handler] [XL]
• sigprocmask() -> set[signal_handler] [XL]
• sigsetmask(self:subtype[signal_handler]) -> set[signal_handler] [XL]
• sigsuspend(self:subtype[signal_handler]) -> void [XL]
• sigunblock(self:subtype[signal_handler]) -> set[signal_handler] [XL]

Starting with XL CLAIRE we can install an Interrupt Service Routine written in CLAIRE for a particular signal. Signals, in XL CLAIRE, are not true asynchronous event since they are always caught by the Kernel as a first step and redistributed to the meta code from an appropriate execution point (necessary to preserve memory integrity) : the meta handling is always performed in the program execution flow (i.e. not in the stack of the signal handler) so that the code of the handler may be arbitrary complex.

The signal interface is very similar to C interface, we use signal(sig:signal_handler, p:property) to install a signal handler :

user_interrupt() : void -> error("User interrupt")  (signal(SIGUSR1, user_interrupt))  (raise(SIGUSR1)) // would throw the error above

Notice that in XL CLAIRE after the delivery of a signal the signal is always re-installed. To uninstall a handler one should use the special property SIG_DFL which correspond to a default handling :

(signal(SIGUSR1, SIG_DFL))

We could also ignore a signal using the special property SIG_IGN :

(signal(SIGUSR1, SIG_IGN))

Last, XL CLAIRE comes with another special property SIG_EXT that is set by default to a signal already installed at the time of CLAIRE initialization (as may be done by a library linked with CLAIRE).

However, SIGINT is handled in a particular way (SIGINT is on most UNIX raised with the keyboard when the user types ^C - Control + C). The SIGINT handler, when set to SIG_DFL (default), throws a user interrupt error such to abort the current computation and come back to the interpreter. If, additionally, the debugger is active, SIGINT would behave as a breakpoint.

getitimer(it:itimer) -> tuple(integer, integer)

getitimer returns the current values for timer it (i.e. the interval and the value).

Core/itimer <: thing

• Core/timerno @ Core/itimer : integer

Instances

UNIX timer interface can handle 3 kind of timers:

• The ITIMER_REAL timer decrements in real time. A SIGALRM signal is delivered when this timer expires.
• The ITIMER_VIRTUAL timer decrements in process virtual time. It runs only when the process is executing. A SIGVTALRM signal is delivered when it expires.
• The ITIMER_PROF timer decrements both in process virtual time and when the system is running on behalf of the process. It is designed to be used by interpreters in statistically profiling the execution of interpreted programs. Each time the ITIMER_PROF timer expires, the SIGPROF signal is delivered. Because this signal may interrupt in-progress system calls, programs using this timer must be prepared to restart interrupted system calls.

kill(p:integer, sig:signal_handler) -> void

send the signal sig to the process with pid p.

raise(sig:signal_handler) -> void

raise the given signal to the calling process

setitimer(it:itimer, interval:integer, value:integer) -> tuple(integer, integer)

setitimer sets a timer to the specified interval / value (in milliseconds). If value is non-zero, it indicates the time to the next timer expiration (at reload). If interval is non-zero, it specifies a value to be used in reloading value when the timer expires. Setting interval/value to 0/0 disables a timer. Setting interval to 0 causes a timer to be disabled after its next expiration (assuming value is non-zero). For instance we could implement a timeout as follow :

timeout() : void -> error("Time out !")  (signal(SIGALRM, timeout))  (setitimer(ITIMER_REAL, 0, 10000))

which would raise a time out exception after 10 seconds of (real time) processing.

sigblock(self:subtype[signal_handler]) -> set[signal_handler]

sigblock adds a set of signal to the process signal mask.

signal(sig:signal_handler, p:property) -> property

Install a signal handler for the given signal_handler. A restriction p should exists with the domain void. signal returns the old property associated with the signal handler. One may use special values for the handler p:

• SIG_IGN : ignore the signal
• SIG_EXT : this value is used by signal initializer if a signal is found to be already installed (e.g. by an external library).
• SIG_DFL : restore the default handler (system dependent). SIGINT is handled

signal_handler <: thing

• Core/signo @ signal_handler : integer
• Core/handler @ signal_handler : property

Instances

In claire signals are named objects. signal handling is system dependent and a signal_handler instance may not correspond to a supported signal in which case its value signo will be set to -1.

sigpending() -> set[signal_handler]

sigpending returns the set of signals that are currently blocked from delivery, i.e. the process has been signaled but the delivery is blocked until the signal is unblocked (sigunblock).

sigprocmask() -> set[signal_handler]

sigprocmask returns the set of signal that are part of the process signal mask, that is the set of signal that the subsystem blocks from delivery.

sigsetmask(self:subtype[signal_handler]) -> set[signal_handler]

sigsetmask sets the set of signal for the process signal mask, that is the set of signal that the subsystem blocks from delivery.

sigsuspend(self:subtype[signal_handler]) -> void

sigsuspend temporarily changes the process signal mask to the set sigs, and then wait for a signal to arrive; on return the previous set of masked signals is restored. The signal mask set is usually empty to indicate that all signals are to be unblocked for the duration of the call.

sigunblock(self:subtype[signal_handler]) -> set[signal_handler]

sigunblock removes a set of signal to the process signal mask.