package async_unix

  1. Overview
  2. Docs
package async_unix
Legend:
Library
Module
Module type
Parameter
Class
Class type

Signal handling.

To discourage use of the Signal.Expert module, we hide it here. People can use Core.Signal.Expert if they need.

include module type of Core.Signal with type t = Core.Signal.t with module Expert := Core.Signal.Expert
type t = Core.Signal.t
val bin_t : t Core__.Import.Bin_prot.Type_class.t
val bin_read_t : t Core__.Import.Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Core__.Import.Bin_prot.Read.reader
val bin_reader_t : t Core__.Import.Bin_prot.Type_class.reader
val bin_size_t : t Core__.Import.Bin_prot.Size.sizer
val bin_write_t : t Core__.Import.Bin_prot.Write.writer
val bin_writer_t : t Core__.Import.Bin_prot.Type_class.writer
val bin_shape_t : Core__.Import.Bin_prot.Shape.t
val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
include Core_kernel.Comparable.S with type t := t
include Base.Comparable.S with type t := 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 min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness = Core.Signal.comparator_witness
val comparator : (t, comparator_witness) Base__.Comparator.comparator
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
module Replace_polymorphic_compare = Core.Signal.Replace_polymorphic_compare
module Map = Core.Signal.Map
module Set = Core.Signal.Set
include Core_kernel.Hashable.S with type t := t
include Core_kernel.Hashable.Common with type t := t
val compare : t -> t -> Base.Int.t
val hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
val hashable : t Core_kernel__.Hashtbl.Hashable.t
module Table = Core.Signal.Table
module Hash_set = Core.Signal.Hash_set
module Hash_queue = Core.Signal.Hash_queue
val of_string : string -> t
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 = [
  1. | `Continue
    (*

    Continue the process if it is currently stopped

    *)
  2. | `Dump_core
    (*

    Terminate the process and dump core

    *)
  3. | `Ignore
    (*

    Ignore the signal

    *)
  4. | `Stop
    (*

    Stop the process

    *)
  5. | `Terminate
    (*

    Terminate the process

    *)
]

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 sys_behavior_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> sys_behavior
val __sys_behavior_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> sys_behavior
val sexp_of_sys_behavior : sys_behavior -> Ppx_sexp_conv_lib.Sexp.t
val default_sys_behavior : t -> sys_behavior

Queries the default system behavior for a signal.

type pid_spec = [
  1. | `Pid of Core_kernel.Pid.t
  2. | `My_group
  3. | `Group of Core_kernel.Pid.t
]
val sexp_of_pid_spec : pid_spec -> Ppx_sexp_conv_lib.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_kernel.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 = [
  1. | `Set
  2. | `Block
  3. | `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, 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 Stable = Core.Signal.Stable
val handle_default : [ `Do_not_use_with_async ] -> _

We override values from Core.Signal that we don't want people to use with Async.

val ignore : [ `Do_not_use_with_async ] -> _
val handle : ?stop:unit Async_kernel.Deferred.t -> t list -> f:(t -> unit) -> unit

handle ?stop signals ~f arranges so that whenever a signal in signals is delivered, f is called on that signal. If f raises, then an exception will be raised to the monitor in effect when handle was called.

Multiple calls to handle with the same signal will cause all the handlers to run when that signal is delivered, not just the last handler from the last call to handle.

The first time handle is called for a signal, it will install a C signal handler for it, replacing the existing C signal handler for that signal.

val terminating : t list

terminating is a list of signals that can be supplied to handle and whose default behavior is to terminate the program: alrm hup int term usr1 usr2.

Various signals whose default_sys_behavior is `Terminate are not included:

       | kill   | it's not allowed to be handled                            |
       | pipe   | Async already ignores this signal, since it handles EPIPE |
       | prof   | so that we can profile things with -p                     |
       | vtalrm | it already has a handler                                  |
val is_managed_by_async : t -> bool

is_managed_by_async signal returns true iff signal is being managed by Async, and hence its default behavior is no longer in effect.

OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct