# Module Std.Linux_ext

    module Linux_ext: Linux_ext

Interface to Linux-specific system calls

## sysinfo

    module Sysinfo: sig .. end

## Filesystem functions

    val sendfile : (?pos:int ->
            ?len:int -> fd:Core_unix.File_descr.t -> Core_unix.File_descr.t -> int)
           Core_kernel.Std.Or_error.t

`sendfile ?pos ?len ~fd sock` sends mmap-able data from file descriptor `fd` to socket `sock` using offset `pos` and length `len`.
Raises `Unix_error` on Unix-errors.
Returns the number of characters actually written.

NOTE: if the returned value is unequal to what was requested (= the initial size of the data by default), the system call may have been interrupted by a signal, the source file may have been truncated during operation, or a timeout occurred on the socket during sending. It is currently impossible to find out which of the events above happened. Calling `Linux_ext.sendfile` several times on the same descriptor that only partially accepted data due to a timeout will eventually lead to the unix error `EAGAIN`.

## Non-portable TCP-functionality

    type tcp_bool_option =

`|` | `TCP_CORK`

    val gettcpopt_bool : (Core_unix.File_descr.t -> tcp_bool_option -> bool)
           Core_kernel.Std.Or_error.t

`gettcpopt_bool sock opt`
Returns the current value of the boolean TCP socket option `opt` for socket `sock`.

    val settcpopt_bool : (Core_unix.File_descr.t -> tcp_bool_option -> bool -> unit)
           Core_kernel.Std.Or_error.t

`settcpopt_bool sock opt v` sets the current value of the boolean TCP socket option `opt` for socket `sock` to value `v`.

    val send_nonblocking_no_sigpipe : (Core_unix.File_descr.t -> ?pos:int -> ?len:int -> string -> int option)
           Core_kernel.Std.Or_error.t

`send_nonblocking_no_sigpipe sock ?pos ?len buf` tries to do a nonblocking send on socket `sock` given buffer `buf`, offset `pos` and length `len`. Prevents `SIGPIPE`, i.e. raise a Unix-error in that case immediately.
Raises

- `Invalid_argument` if the designated buffer range is invalid.
- `Unix_error` on Unix-errors.

Returns `Some bytes_written` or `None` if the operation would have blocked.

    val send_no_sigpipe : (Core_unix.File_descr.t -> ?pos:int -> ?len:int -> string -> int)
           Core_kernel.Std.Or_error.t

`send_no_sigpipe sock ?pos ?len buf` tries to do a blocking send on socket `sock` given buffer `buf`, offset `pos` and length `len`. Prevents `SIGPIPE`, i.e. raise a Unix-error in that case immediately.
Raises

- `Invalid_argument` if the designated buffer range is invalid.
- `Unix_error` on Unix-errors.

Returns the number of bytes written.

    val sendmsg_nonblocking_no_sigpipe : (Core_unix.File_descr.t ->
            ?count:int -> string Core_unix.IOVec.t array -> int option)
           Core_kernel.Std.Or_error.t

`sendmsg_nonblocking_no_sigpipe sock ?count iovecs` tries to do a nonblocking send on socket `sock` using `count` I/O-vectors `iovecs`. Prevents `SIGPIPE`, i.e. raises a Unix-error in that case immediately.
Raises

- `Invalid_argument` if the designated ranges are invalid.
- `Unix_error` on Unix-errors.

Returns `Some bytes_written` or `None` if the operation would have blocked.

## Clock functions

    module Clock: sig .. end

## Timerfd functions

    module Timerfd: sig .. end

## Parent death notifications

    val pr_set_pdeathsig : (Signal.t -> unit) Core_kernel.Std.Or_error.t

`pr_set_pdeathsig s` sets the signal `s` to be sent to the executing process when its parent dies. NOTE: the parent may have died before or while executing this system call. To make sure that you do not miss this event, you should call `getppid` to get the parent process id after this system call. If the parent has died, the returned parent PID will be 1, i.e. the init process will have adopted the child. You should then either send the signal to yourself using Unix.kill, or execute an appropriate handler.

    val pr_get_pdeathsig : (unit -> Signal.t) Core_kernel.Std.Or_error.t

`pr_get_pdeathsig ()` get the signal that will be sent to the currently executing process when its parent dies.

## Task name

    val pr_set_name_first16 : (string -> unit) Core_kernel.Std.Or_error.t

`pr_set_name_first16 name` sets the name of the executing thread to `name`. Only the first 16 bytes in `name` will be used, the rest is ignored.

    val pr_get_name : (unit -> string) Core_kernel.Std.Or_error.t

`pr_get_name ()` gets the name of the executing thread. The name is at most 16 bytes long.

## Pathname resolution

    val file_descr_realpath : (Core_unix.File_descr.t -> string) Core_kernel.Std.Or_error.t

`file_descr_realpath fd`
Raises `Unix_error` on errors.
Returns the canonicalized absolute pathname of the file associated with file descriptor `fd`.

    val out_channel_realpath : (Pervasives.out_channel -> string) Core_kernel.Std.Or_error.t

`out_channel_realpath oc`
Raises `Unix_error` on errors.
Returns the canonicalized absolute pathname of the file associated with output channel `oc`.

    val in_channel_realpath : (Pervasives.in_channel -> string) Core_kernel.Std.Or_error.t

`in_channel_realpath ic`
Raises `Unix_error` on errors.
Returns the canonicalized absolute pathname of the file associated with input channel `ic`.

## Affinity

    val sched_setaffinity : (?pid:Core_kernel.Std.Pid.t -> cpuset:int list -> unit -> unit)
           Core_kernel.Std.Or_error.t

    val sched_setaffinity_this_thread : (cpuset:int list -> unit) Core_kernel.Std.Or_error.t

    val cores : (unit -> int) Core_kernel.Std.Or_error.t

`cores ()`
Returns the number of cores on the machine. This may be different than the number of cores available to the calling process.

    val get_terminal_size : (unit -> int * int) Core_kernel.Std.Or_error.t

`get_terminal_size ()`
Returns `(rows, cols)`, the number of rows and columns of the terminal.

    module Priority: sig .. end

    val setpriority : (Priority.t -> unit) Core_kernel.Std.Or_error.t

Set the calling thread's priority in the linux scheduler

    val getpriority : (unit -> Priority.t) Core_kernel.Std.Or_error.t

Get the calling thread's priority in the linux scheduler

    val get_ipv4_address_for_interface : (string -> string) Core_kernel.Std.Or_error.t

    val bind_to_interface : (Core_unix.File_descr.t -> [ `Any | `Interface_name of string ] -> unit)
           Core_kernel.Std.Or_error.t

    module Epoll: sig .. end

epoll() - a linux I/O multiplexer of the same family as select() or poll().

    val bin_tcp_bool_option : tcp_bool_option Core_kernel.Std.Bin_prot.Type_class.t

    val bin_read_tcp_bool_option : tcp_bool_option Core_kernel.Std.Bin_prot.Read.reader

    val __bin_read_tcp_bool_option__ : (int -> tcp_bool_option) Core_kernel.Std.Bin_prot.Read.reader

    val bin_reader_tcp_bool_option : tcp_bool_option Core_kernel.Std.Bin_prot.Type_class.reader

    val bin_size_tcp_bool_option : tcp_bool_option Core_kernel.Std.Bin_prot.Size.sizer

    val bin_write_tcp_bool_option : tcp_bool_option Core_kernel.Std.Bin_prot.Write.writer

    val bin_writer_tcp_bool_option : tcp_bool_option Core_kernel.Std.Bin_prot.Type_class.writer

    val tcp_bool_option_of_sexp : Sexplib.Sexp.t -> tcp_bool_option

    val sexp_of_tcp_bool_option : tcp_bool_option -> Sexplib.Sexp.t

`gettcpopt_bool sock opt`
`settcpopt_bool sock opt v` sets the current value of the boolean TCP socket option `opt` for socket `sock` to value `v`.
`send_nonblocking_no_sigpipe sock ?pos ?len buf` tries to do a nonblocking send on socket `sock` given buffer `buf`, offset `pos` and length `len`. Prevents `SIGPIPE`, i.e. raise a Unix-error in that case immediately.
`send_no_sigpipe sock ?pos ?len buf` tries to do a blocking send on socket `sock` given buffer `buf`, offset `pos` and length `len`. Prevents `SIGPIPE`, i.e. raise a Unix-error in that case immediately.
`sendmsg_nonblocking_no_sigpipe sock ?count iovecs` tries to do a nonblocking send on socket `sock` using `count` I/O-vectors `iovecs`. Prevents `SIGPIPE`, i.e. raises a Unix-error in that case immediately.

## Clock functions

`get_process_clock` the clock measuring the CPU-time of a process.
`get_thread_clock` the clock measuring the CPU-time of the current thread.

## Timerfd functions

Clock used to mark the progress of a timer.
Settable system-wide clock.
Nonsettable clock. It is not affected by manual changes to the system time.
`TFD_NONBLOCK`
`TFD_CLOEXEC`
`create ?flags clock` creates a new timer file descriptor. With Linux 2.6.26 or earlier `flags` must be empty.
`set_at t at` and `set_after t span` set `t` to fire once, at `at` or after `span`. `set_after` treats `span <= 0` as `span = 1ns`; unlike the underlying system call, `timerfd_settime`, it does not clear the timer if `span = 0`. To clear a timerfd, use `Timerfd.clear`.

`set_repeating ?after t interval` sets `t` to fire every `interval` starting after `after` (default is `interval`), raising if `interval <= 0`.
`clear t` causes `t` to not fire any more.
`get t` returns the current state of the timer `t`.

## Parent death notifications

`pr_set_pdeathsig s` sets the signal `s` to be sent to the executing process when its parent dies. NOTE: the parent may have died before or while executing this system call. To make sure that you do not miss this event, you should call `getppid` to get the parent process id after this system call. If the parent has died, the returned parent PID will be 1, i.e. the init process will have adopted the child. You should then either send the signal to yourself using Unix.kill, or execute an appropriate handler.
`pr_get_pdeathsig ()` get the signal that will be sent to the currently executing process when its parent dies.

## Task name

`pr_set_name_first16 name` sets the name of the executing thread to `name`. Only the first 16 bytes in `name` will be used, the rest is ignored.
`pr_get_name ()` gets the name of the executing thread. The name is at most 16 bytes long.

## Pathname resolution

`file_descr_realpath fd`
`out_channel_realpath oc`
`in_channel_realpath ic`

## Affinity

`cores ()`
`get_terminal_size ()`
Set the calling thread's priority in the linux scheduler
Get the calling thread's priority in the linux scheduler
epoll() - a linux I/O multiplexer of the same family as select() or poll(). Its main differences are support for Edge or Level triggered notifications (We're using Level-triggered to emulate select) and much better scaling with the number of file descriptors.

See the man pages for a full description of the epoll facility.
An `Epoll.Flags.t` is an immutable set of flags for which one can register interest for a file descriptor. It is implemented as a bitmask, and so all operations (+, -, etc.) are constant time with no allocation.

`sexp_of_t` produces a human-readable list of bits, e.g. "(in out)".
An `Epoll.t` maintains a map from `File_descr.t` to `Flags.t`, where the domain is the set of file descriptors that one is interested in, and the flags associated with each file descriptor specify the types of events one is interested in being notified about for that file descriptor. Our implementation maintains a user-level table equivalent to the kernel epoll set, so that `sexp_of_t` produces useful human-readable information, and so that we can present our standard table interface.

The implementation assumes that one never closes a file descriptor that is the domain of an `Epoll.t`, since doing so might remove the fd from the kernel epoll set without the implementation's knowledge.

An `Epoll.t` also has a buffer that is used to store the set of ready fds returned by calling `wait`.
`create ~num_file_descrs` creates a new epoll set able to watch file descriptors in [0, num_file_descrs). Additionally, the set allocates space for reading the ready events when `wait` returns, allowing for up to `max_ready_events` to be returned in a single call to `wait`.
map operations
`wait t ~timeout` blocks until at least one file descriptor in `t` is ready for one of the events it is being watched for, or `timeout` passes. `wait` side effects `t` by storing the ready set in it. One can subsequently access the ready set by calling `iter_ready` or `fold_ready`.

With `wait ~timeout:(`After span)`, `span <= 0` is treated as `0`. If `span > 0`, then `span` is rounded to the nearest millisecond, with a minimum value of one millisecond.

Note that this method should not be considered thread safe. There is mutable state in `t` that will be changed by invocations to wait that cannot be prevented by mutexes around `wait`.
`wait_timeout_after t span = wait t ~timeout:(`After span)`. `wait_timeout_after` is a performance hack to avoid allocating ``After span`.
`iter_ready` and `fold_ready` iterate over the ready set computed by the last call to `wait`.