Module Core__Signal

Signal handlers.

type t
include sig ... end
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int ‑> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Base.Sexp.t ‑> t
val sexp_of_t : t ‑> Base.Sexp.t
include Core__.Import.Comparable.S with type t := t
include Core_kernel__.Comparable_intf.S_common
include Base.Comparable.S
include Base__.Comparable_intf.Polymorphic_compare
include Base.Comparisons.Infix
type t
val (>=) : t ‑> t ‑> bool
val (<=) : t ‑> t ‑> bool
val (=) : t ‑> t ‑> bool
val (>) : t ‑> t ‑> bool
val (<) : t ‑> t ‑> bool
val (<>) : t ‑> t ‑> bool
val equal : t ‑> t ‑> bool
val compare : t ‑> t ‑> int

compare t1 t2 returns 0 if t1 is equal to t2, a negative integer if t1 is less than t2, and a positive integer if t1 is greater than t2.

val min : t ‑> t ‑> t
val max : t ‑> t ‑> t
val ascending : t ‑> t ‑> int

ascending is identical to compare. descending x y = ascending y x. These are intended to be mnemonic when used like List.sort ~compare:ascending and List.sort ~cmp:descending, since they cause the list to be sorted in ascending or descending order, respectively.

val descending : t ‑> t ‑> int
val between : t ‑> low:t ‑> high:t ‑> bool

between t ~low ~high means low <= t <= high

val clamp_exn : t ‑> min:t ‑> max:t ‑> t

clamp_exn t ~min ~max returns t', the closest value to t such that between t' ~low:min ~high:max is true.

Raises if not (min <= max).

val clamp : t ‑> min:t ‑> max:t ‑> t Base.Or_error.t
include Base.Comparator.S with type t := t
type t
type comparator_witness
include Base__.Comparable_intf.Validate with type t := t
type t
val validate_lbound : min:t Base.Maybe_bound.t ‑> t Base.Validate.check
val validate_ubound : max:t Base.Maybe_bound.t ‑> t Base.Validate.check
val validate_bound : min:t Base.Maybe_bound.t ‑> max:t Base.Maybe_bound.t ‑> t Base.Validate.check
include Core__.Import.Hashable.S with type t := t
include Core__.Import.Hashable.Common
type t
include sig ... end
val compare : t ‑> t ‑> Core_kernel__.Import.int
val hash_fold_t : Base.Hash.state ‑> t ‑> Base.Hash.state
val hash : t ‑> Base.Hash.hash_value
module Table : Core_kernel.Hashtbl.S with type key = t
module Hash_set : Core_kernel.Hash_set.S with type elt = t
include Core__.Import.Stringable.S with type t := t
type t
val of_string : string ‑> t
val to_string : t ‑> string
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 OCaml 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 sys_behavior = [
| `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).

include sig ... end
val sys_behavior_of_sexp : Base.Sexp.t ‑> sys_behavior
val __sys_behavior_of_sexp__ : Base.Sexp.t ‑> sys_behavior
val sexp_of_sys_behavior : sys_behavior ‑> Base.Sexp.t
val default_sys_behavior : t ‑> sys_behavior

Queries the default system behavior for a signal.

val handle_default : t ‑> unit

handle_default t is set t `Default.

val ignore : t ‑> unit

ignore t is set t `Ignore.

type pid_spec = [
| `Pid of Core__.Import.Pid.t
| `My_group
| `Group of Core__.Import.Pid.t
]
include sig ... end
val sexp_of_pid_spec : pid_spec ‑> Base.Sexp.t
val send : t ‑> pid_spec ‑> [ `Ok | `No_such_process ]

send signal pid_spec sends signal to the processes specified by pid_spec.

send_i is like send, except that it silently returns if the specified processes don't exist.

send_exn is like send, except that it raises if the specified processes don't exist.

All of send, send_i, and send_exn raise if you don't have permission to send the signal to the specified processes or if signal is unknown.

val send_i : t ‑> pid_spec ‑> unit
val send_exn : t ‑> pid_spec ‑> unit
val can_send_to : Core__.Import.Pid.t ‑> bool

can_send_to pid returns true if pid is running and the current process has permission to send it signals.

type sigprocmask_command = [
| `Set
| `Block
| `Unblock
]
val sigprocmask : sigprocmask_command ‑> t list ‑> t list

sigprocmask cmd sigs changes 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, along with their default behavior and meaning.

val abrt : t

Dump_core Abnormal termination

val alrm : t

Terminate Timeout

val bus : t

Dump_core Bus error

val chld : t

Ignore Child process terminated

val cont : t

Continue Continue

val fpe : t

Dump_core Arithmetic exception

val hup : t

Terminate Hangup on controlling terminal

val ill : t

Dump_core Invalid hardware instruction

val int : t

Terminate Interactive interrupt (ctrl-C)

val kill : t

Terminate Termination (cannot be ignored)

val pipe : t

Terminate Broken pipe

val poll : t

Terminate Pollable event

val prof : t

Terminate Profiling interrupt

val quit : t

Dump_core Interactive termination

val segv : t

Dump_core Invalid memory reference

val sys : t

Dump_core Bad argument to routine

val stop : t

Stop Stop

val term : t

Terminate Termination

val trap : t

Dump_core Trace/breakpoint trap

val tstp : t

Stop Interactive stop

val ttin : t

Stop Terminal read from background process

val ttou : t

Stop Terminal write from background process

val urg : t

Ignore Urgent condition on socket

val usr1 : t

Terminate Application-defined signal 1

val usr2 : t

Terminate Application-defined signal 2

val vtalrm : t

Terminate Timeout in virtual time

val xcpu : t

Dump_core Timeout in cpu time

val xfsz : t

Dump_core File size limit exceeded

val zero : t

Ignore No-op; can be used to test whether the target process exists and the current process has permission to signal it

module Expert : sig ... end

The Expert module contains functions that novice users should avoid, due to their complexity.

module Stable : sig ... end