Up

Module Signal_manager

A signal manager keeps track of a set of signals to be managed and the signal handlers for them. When a signal manager is managing a signal, it installs its own OCaml handler for that signal that records delivery of the signal. It then later, upon request, will deliver the signal to all its handlers.

Once a signal manager starts managing a signal, it never stops.

Signature

type t
val sexp_of_t : t -> Sexplib.Sexp.t
include Core.Std.Invariant.S with type t := t
type t
val invariant : t Invariant_intf.inv
val create : thread_safe_notify_signal_delivered:(unit -> unit) -> t

create creates and returns a signal manager t. Whenever a signal that t is managing is delivered, it will call thread_safe_notify_signal_delivered from within the OCaml signal handler. Therefore thread_safe_notify_signal_delivered must be thread safe.

val manage : t -> Core.Std.Signal.t -> unit

manage t signal causes t to manage signal, thus overriding default_sys_behavior for that signal, and any other OCaml handler for that signal.

val is_managing : t -> Core.Std.Signal.t -> bool

is_managing t signal returns true iff manage t signal has been called

type handler

install_handler t signals f causes t to manage the handling of signals, and registers f to run on every signal in signals that is delivered. It is an error if f ever raises when it is called.

val install_handler : t -> Core.Std.Signal.t list -> (Core.Std.Signal.t -> unit) -> handler
val remove_handler : t -> handler -> unit

remove_handler handler causes the particular handler to no longer handle the signals it was registered to handle. The signal manager continues to manage those signals, i.e. the OCaml signal handler remains installed, whether or not they still have handlers.

val handle_delivered : t -> unit

handle_delivered t runs all signal handlers on the signals that have been delivered but not yet handled.