module Signal: Signal
type
include Comparable.S
include Hashable.S
include Sexpable.S
include Stringable.S
val equal : t -> t -> bool
val of_system_int : int -> t
of_system_int and to_system_int return and take respectively a signal number
corresponding to those in the system's /usr/include/bits/signum.h (or equivalent). It
is not guaranteed that these numbers are portable across any given pair of systems --
although some are defined as standard by POSIX.
val to_system_int : t -> int
val of_caml_int : int -> t
of_caml_int constructs a Signal.t given an O'Caml internal signal number. This is
only for the use of the Core_unix module.
val to_caml_int : t -> int
val to_string : t -> string
to_string t returns a human-readable name: "sigabrt", "sigalrm", ...
type [ `Continue | `Dump_core | `Ignore | `Stop | `Terminate ]
The default behaviour of the system if these signals trickle to the top level of a
program. See include/linux/kernel.h in the Linux kernel source tree (not the file
/usr/include/linux/kernel.h).
val sexp_of_sys_behavior : sys_behavior -> Sexplib.Sexp.t
val sys_behavior_of_sexp : Sexplib.Sexp.t -> sys_behavior
val sys_behavior_of_sexp__ : Sexplib.Sexp.t -> sys_behavior
type [ `Default | `Handle of t -> unit | `Ignore ]
val default_sys_behavior : t -> sys_behavior
default_sys_behavior t
Query the default system behavior for a signal.
val signal : t -> behavior -> behavior
signal t
Set the behavior of the system on receipt of a given signal. The
first argument is the signal number. Return the behavior
previously associated with the signal. If the signal number is
invalid (or not available on your system), an Invalid_argument
exception is raised.
val set : t -> behavior -> unit
set t b is ignore (signal t b)
val handle : t -> (t -> unit) -> unit
handle t f is set t (`Handle f).
val handle_default : t -> unit
handle_default t is set t `Default.
val ignore : t -> unit
ignore t is set t `Ignore.
type [ `Group of Pid.t | `My_group | `Pid of Pid.t ]
val send : t -> pid_spec -> [ `No_such_process | `Ok ]
send signal pid sends signal to the process whose process id is pid.
val send_i : t -> pid_spec -> unit
send_i signal ~pid sends signal to the process whose process id is pid.
No exception will be raised if pid is a zombie or nonexistent.
val send_exn : t -> pid_spec -> unit
send_exn signal ~pid sends signal to the process whose process id is
pid. In Caml's standard library, this is called Unix.kill. Sending a
signal to a zombie and/or nonexistent process will raise an exception.
type [ `Block | `Set | `Unblock ]
val sigprocmask : sigprocmask_command -> t list -> t list
sigprocmask cmd sigs changes the set of blocked signals.
If cmd is `Set, blocked signals are set to those in the list sigs.
If cmd is `Block, the signals in sigs are added to the set of blocked
signals.
If cmd is `Unblock, the signals in sigs are removed from the set of
blocked signals.
sigprocmask returns the set of previously blocked signals.
val sigpending : unit -> t list
sigpending () returns the set of blocked signals that are currently
pending.
val sigsuspend : t list -> unit
sigsuspend sigs atomically sets the blocked signals to sigs and waits for
a non-ignored, non-blocked signal to be delivered. On return, the blocked
signals are reset to their initial value.
Specific signals
val abrt : t
Abnormal termination
val alrm : t
Timeout
val chld : t
Child process terminated
val cont : t
Continue
val fpe : t
Arithmetic exception
val hup : t
Hangup on controlling terminal
val ill : t
Invalid hardware instruction
val int : t
Interactive interrupt (ctrl-C)
val kill : t
Termination (cannot be ignored)
val pipe : t
Broken pipe
val prof : t
Profiling interrupt
val quit : t
Interactive termination
val segv : t
Invalid memory reference
val stop : t
Stop
val term : t
Termination
val tstp : t
Interactive stop
val ttin : t
Terminal read from background process
val ttou : t
Terminal write from background process
val usr1 : t
Application-defined signal 1
val usr2 : t
Application-defined signal 2
val vtalrm : t
Timeout in virtual time
val zero : t