module Netsys_posix:sig..end
Unix module, and
further API's from POSIX-style operating systems.val int_of_file_descr : Unix.file_descr -> intNetsys.int64_of_file_descr which works for all OS.val file_descr_of_int : int -> Unix.file_descrval sysconf_open_max : unit -> intfd:
fd < sysconf_open_max()val get_nonblock : Unix.file_descr -> boolval fchdir : Unix.file_descr -> unitval fdopendir : Unix.file_descr -> Unix.dir_handleUnix.closedir.
This function is useful in conjunction with Netsys_posix.openat
to read directories relative to a parent directory.
This is a recent addition to the POSIX standard; be prepared to
get Invalid_argument because it is unavailable.
val realpath : string -> stringval getpgid : int -> intval getpgrp : unit -> intgetpgid 0, i.e. returns the process group ID of the
current process.val setpgid : int -> int -> unitsetpgid pid pgid: Set the process group ID of the process pid
to pgid. If pid = 0, the process group ID of the current process
is changed. If pgid = 0, as process group ID the process ID of the
process referenced by pid is used.
It is only possible for a process to join a process group if both
belong to the same session.
val setpgrp : unit -> unitsetpgid 0 0: A new process group ID is created, and the
current process becomes its sole member.val tcgetpgrp : Unix.file_descr -> intval tcsetpgrp : Unix.file_descr -> int -> unitval ctermid : unit -> stringval ttyname : Unix.file_descr -> stringval getsid : int -> intval with_tty : (Unix.file_descr -> unit) -> unitwith_tty f: Runs f fd where fd is the terminal of the process.
If the process does not have a terminal (because it is a daemon)
with_tty will fail.val tty_read_password : ?tty:Unix.file_descr -> string -> stringtty_read_password prompt: If tty is a terminal, the prompt
is printed, and a password is read from the terminal (echo off).
If tty is not a terminal, no prompt is printed, and just a
line is read from the tty descriptor (non-interactive case).
tty defaults to Unix.stdin. If this function is used in a
program where stdin is not redirected, and the program is started
in a terminal, it will read the password with prompt and
echo disabled. If stdin is redirected, it is assumed that the program is
used in a script, and the password is piped into it.
Use in conjunction with with_tty to ensure that tty is
the terminal even if a redirection is in effect, e.g.
with_tty (fun tty -> tty_read_password ~tty prompt)
Raises Sys.Break if the user triggers SIGINT (i.e. presses
CTRL-C) to abort the input of a password.
val posix_openpt : bool -> Unix.file_descrposix_openpt noctty: Opens an unused PTY master.
noctty: If true, the descriptor will not become the controlling
terminal.
If this function is not provided by the OS, an emulation is used.
On some OS, System V style PTY's are unavailable (but they get
rare).
val grantpt : Unix.file_descr -> unitval unlockpt : Unix.file_descr -> unitval ptsname : Unix.file_descr -> stringtype node_type =
| |
S_IFREG |
| |
S_IFCHR of |
| |
S_IFBLK of |
| |
S_IFIFO |
| |
S_IFSOCK |
val mknod : string -> int -> node_type -> unitval setreuid : int -> int -> unitval setregid : int -> int -> unitval initgroups : string -> int -> unitopenat and then by using a function that references the file
by descriptor. An example for this is fstatat: After the
openat call one can use fstat to get the stat record of the
file.val have_at : unit -> bool*at functions are available (they were only recently
standardized and cannot be expected on all OS yet)val at_fdcwd : Unix.file_descr*at
functionstype at_flag =
| |
AT_EACCESS |
|||
| |
AT_SYMLINK_NOFOLLOW |
|||
| |
AT_REMOVEDIR |
(* | Flags one can pass to "at" functions. Not all functions support all flags | *) |
val openat : Unix.file_descr ->
string -> Unix.open_flag list -> Unix.file_perm -> Unix.file_descrUnix.openfile but open relative to the directory given
by first argumentval faccessat : Unix.file_descr ->
string -> Unix.access_permission list -> at_flag list -> unitUnix.access but the file is taken relative to the directory
given by first argumentval mkdirat : Unix.file_descr -> string -> int -> unitUnix.mkdir but the file is taken relative to the directory
given by first argumentval renameat : Unix.file_descr -> string -> Unix.file_descr -> string -> unitrenameat olddirfd oldpath newdirfd newpathval linkat : Unix.file_descr ->
string -> Unix.file_descr -> string -> at_flag list -> unitlinkat olddirfd oldpath newdirfd newpath flagsval unlinkat : Unix.file_descr -> string -> at_flag list -> unitUnix.unlink but unlink the file relative to the directory
given by first argumentval symlinkat : string -> Unix.file_descr -> string -> unitsymlinkat oldpath newdirfd newpath flagsval mkfifoat : Unix.file_descr -> string -> int -> unitmkfifoat dirfd path modeval readlinkat : Unix.file_descr -> string -> stringreadlinkat dirfd pathtype poll_array
poll_cell entriestype poll_req_events
type poll_act_events
poll_req_events is used to request that certain
event types are observed. poll_act_event shows which
event types are actually possibletype poll_cell = {
|
mutable poll_fd : |
|
mutable poll_req_events : |
|
mutable poll_act_events : |
poll_fd. The poll_req_events
are the events the descriptor is polled for. The poll_act_events
are the actually reported events.val have_poll : unit -> boolpoll implementation on this OSval poll_req_events : bool -> bool -> bool -> poll_req_eventspoll_req_events rd wr pri: Create a set of in events consisting
of the bits rd, wr, and pri. rd means to poll for
input data, wr to poll for output data, and pri to poll for urgent
input data.val poll_req_triple : poll_req_events -> bool * bool * boolpoll_req_events value, and returns the triple
(rd,wr,pri).val poll_null_events : unit -> poll_act_eventspoll_act_events, for initilization
of poll cells.val poll_result : poll_act_events -> boolpoll_out_eventsval poll_rd_result : poll_act_events -> bool
val poll_wr_result : poll_act_events -> bool
val poll_pri_result : poll_act_events -> bool
val poll_err_result : poll_act_events -> bool
val poll_hup_result : poll_act_events -> bool
val poll_nval_result : poll_act_events -> boolpoll_act_events and return the statusval create_poll_array : int -> poll_arraypoll_fd member is
initialized with Unix.stdin, and the two event members are empty.val set_poll_cell : poll_array -> int -> poll_cell -> unitset_poll_cell a k c: Sets the poll cell k to c.
The index k must be in the range from 0 to N-1 when N is the
length of the poll array.val get_poll_cell : poll_array -> int -> poll_cellget_poll_cell a k: Returns the poll cell k.
The index k must be in the range from 0 to N-1 when N is the
length of the poll array.val blit_poll_array : poll_array ->
int -> poll_array -> int -> int -> unitblit_poll_array a1 p1 a2 p2 len: Copies the len cells at index p1
from a1 to a2 at index p2.val poll_array_length : poll_array -> intval poll : poll_array -> int -> float -> intpoll a n tmo: Poll for the events of the cells 0 to n-1 of
poll array a, and set the poll_act_events member of all cells.
Wait for at most tmo seconds (a negative value means there is
no timeout). Returns the number of ready file descriptors.
On platforms without native support for poll the function is
emulated using Unix.select. Note, however, that there is a
performance penalty for the emulation, and that the output
flags poll_error_result, poll_hangup_result, and
poll_invalid_result are not emulated.
val restarting_poll : poll_array -> int -> float -> intpoll that handles the EINTR conditionval poll_single : Unix.file_descr -> bool -> bool -> bool -> float -> boolpoll_single fd rd wr pri tmo: Polls a single descriptor for the
events given by rd, wr, and pri. In tmo the timeout can be
passed. Returns true if one of the requested events is indicated
for the descriptor. The EINTR case is not handled.poll_req_events and poll_act_events are integers that
are bitmasks of some constants. The following functions allow access to
this detail.val int_of_req_events : poll_req_events -> int
val int_of_act_events : poll_act_events -> int
val req_events_of_int : int -> poll_req_events
val act_events_of_int : int -> poll_act_events
val const_rd_event : int
val const_wr_event : int
val const_pri_event : int
val const_err_event : int
val const_hup_event : int
val const_nval_event : intepoll for Linux is supported.
The model exhibited in this API is the smallest common denominator
of Linux epoll, BSD kqueue, and Solaris ports. The event_aggregator
represents the set of monitored event sources. There is, so far,
only one source, namely file descriptors, i.e. one can check whether
a descriptor is readable or writable (like poll). The source can
be added to the event_aggregator to monitor the source.
By calling poll_event_sources one can determine sources that
are currently active (i.e. in signalling state).
It is undefined what happens when a file descriptor is closed while
being member of the aggregator.
type event_aggregator
type event_source
val have_event_aggregation : unit -> boolval create_event_aggregator : bool -> event_aggregatorcreate_event_aggregator is_interruptible: Creates a new aggregator,
and allocates the required OS resources.
If is_interruptible, the aggregator can be interrupted from a
different thread. See interrupt_event_aggregator below.
val destroy_event_aggregator : event_aggregator -> unitval fd_event_source : Unix.file_descr -> poll_req_events -> event_sourcepoll_req_events.
The event_source contains
state about the relation to the aggregator, and because of this,
the event_source should only be used together with one aggregator
(at a time).
val modify_fd_event_source : event_source -> poll_req_events -> unitval get_fd_of_event_source : event_source -> Unix.file_descrval act_events_of_event_source : event_source -> poll_act_eventspoll_event_sources returns the source.val add_event_source : event_aggregator -> event_source -> unitval del_event_source : event_aggregator -> event_source -> unitval interrupt_event_aggregator : event_aggregator -> unitcreate_event_aggregator was called with true as argument, the
aggregator is interruptible, and this function interrupts it. The
effect is that a currently running poll_event_sources, or, if
it is not running, the next invocation of poll_event_sources
returns immediately.
If the aggregator is not interruptible, this function is a NOP.
val push_event_updates : event_aggregator -> unitval poll_event_sources : event_aggregator -> float -> event_source listpoll_event_sources ea tmo: First, all modifications are pushed
to the kernel, and polling is set up to get events. If no events
can currently be delivered, the function waits up to tmo seconds
(or endlessly if negative) for events. The function returns only a
limited number of events at a time. It is allowed that the function
returns fewer events than are currently in signalled state, even
none.
Call the function with tmo=0.0 for non-blocking behavior.
Note that this is the "level-triggered" behavior: If a source
remains active it will be reported again by the next poll_event_sources,
just as poll would do.
val event_aggregator_fd : event_aggregator -> Unix.file_descrpush_event_updates before polling from the descriptor.Unix.fork at some places to create child processes
for doing real work. The following functions
allow it to register a handler that is run in the forked child
process. Note that this is done by the O'caml code calling fork,
and not via the POSIX atfork() facility.
The handler should release OS resources like file descriptors that are by default shared with the parent process.
The handler are not invoked when the only purpose of the fork is
to exec a different process.
class type post_fork_handler =object..end
post_fork_handler is a named function unit -> unit
val register_post_fork_handler : post_fork_handler -> unitval remove_post_fork_handler : post_fork_handler -> unitval run_post_fork_handlers : unit -> unittype wd_spec =
| |
Wd_keep |
(* | Keep the current working directory in the spawned process | *) |
| |
Wd_chdir of |
(* | Change to this directory in the spawned process | *) |
| |
Wd_fchdir of |
(* | Change to the directory which has been previously been opened | *) |
type pg_spec =
| |
Pg_keep |
(* | The new process will be member of the same process group as this process | *) |
| |
Pg_new_bg_group |
(* | A new background process group is created, and the spawned process will be its single member | *) |
| |
Pg_new_fg_group |
(* | A new foreground process group is created, and the spawned process will be its single member | *) |
| |
Pg_join_group of |
(* | The spawned process will be member of this process group | *) |
type fd_action =
| |
Fda_close of |
(* | Close the descriptor | *) |
| |
Fda_close_ignore of |
(* | Close the descriptor but ignore EBADF errors | *) |
| |
Fda_close_except of |
(* | Closes all descriptors except those for which
except.(k) is true where k = int_of_file_descr fd.
Descriptors outside the array index range are closed. | *) |
| |
Fda_dup2 of |
(* | Duplicate the first descriptor to the second as dup2 does | *) |
type sig_action =
| |
Sig_default of |
(* | Resets this signal to default behavior in the spawned process | *) |
| |
Sig_ignore of |
(* | Ignores the signal in the spawned process | *) |
| |
Sig_mask of |
(* | Set the signal mask in the spawned process | *) |
val spawn : ?chdir:wd_spec ->
?pg:pg_spec ->
?fd_actions:fd_action list ->
?sig_actions:sig_action list ->
?env:string array -> ?no_posix_spawn:bool -> string -> string array -> intspawn cmd args: Fork the process and exec cmd which gets the
arguments args. On success, the PID of the new process is returned.
This function does not wait for the completion of the process; use
Unix.waitpid for this purpose.
chdir: If set, the new process starts with this working directory
(this is done before anything else)pg: If set, the new process will be a member of this process groupfd_actions: If set, these descriptor actions are executed
sequentiallysig_actions: If set, these signal actions are executed sequentiallyenv: If set, the process gets this environment instead of the
current oneno_posix_spawn: If set, the posix_spawn family of library
functions is not used to spawn even if possible, and always a
fork/exec approach is taken. This may be slower, but there is
normally better error reporting.Fda_close_ignore leads to EBADF for a descriptor, this error is
ignored.
If pg=Pg_new_fg_group, one should include Sig_ignore Sys.sigttou
in sig_actions.
There are two implementations for spawn: One calls fork and exec
directly, and one uses the posix_spawn family of library functions.
The latter is faster on certain conditions, but this is very OS-specific.
A number of features are not supported by posix_spawn and will force
that fork/exec is used: Wd_chdir, Wd_fchdir, Pg_new_fg_group,
and Sig_ignore. However, note some implementations of posix_spawn
also fall back to fork/exec internally for some combinations of flags,
and it is hard to predict which spawn calls can actually be accelerated.
The tendency, though, is that recent OS have sped up posix_spawn
so far possible (e.g. by using vfork internally, or even by making
posix_spawn a system call).
eventfd
system call. On other platforms, pipes are used for emulation.
A not_event can have two states: off and on. Initially, the
not_event is off. By signalling it, the state changes to on,
and the underlying real file descriptor becomes readable.
By consuming the event, the state is switched back to off.
Note that a similar API exists for Win32: See Netsys_win32.w32_event.
type not_event
val create_event : unit -> not_eventval set_nonblock_event : not_event -> unitval get_event_fd : not_event -> Unix.file_descrval set_event : not_event -> unitval wait_event : not_event -> unitval consume_event : not_event -> unitEAGAIN
or EWOULDBLOCK (in non-blocking mode).
This is effectively an atomic "wait-and-reset" operation.
val destroy_event : not_event -> unitget_event_fd
is not sufficient.val report_signal_as_event : not_event -> int -> unitreport_signal_as_event ev sig Installs a new signal handler for
signal sig so that ev is signalled when a signal arrives.install_subprocess_handlertype watched_subprocess
val watch_subprocess : int -> int -> bool -> Unix.file_descr * watched_subprocesslet fd, ws = watch_subprocess pid pgid kill_flag:
Enters the subprocess pid
into the watch list. If pgid > 0, the process group ID is
pgid (for killpg_subprocess and killpg_all_subprocesses).
The kill_flag controls the process selection of
kill_all_subprocesses and killpg_all_subprocesses.
The returned descriptor fd is open for reading and
will indicate EOF when the subprocess is terminated. Via ws
it is possible to query information about the subprocess. The
installed signal handler will wait for the subprocess and
put the process status into ws.
The caller has to close fd after the termination is signaled.
val ignore_subprocess : watched_subprocess -> unitwaits for the subprocess
to avoid zombies.
Any further access to ws will fail.
val forget_subprocess : watched_subprocess -> unitws will fail.val get_subprocess_status : watched_subprocess -> Unix.process_status optionNone is returnedval kill_subprocess : int -> watched_subprocess -> unitval killpg_subprocess : int -> watched_subprocess -> unitval kill_all_subprocesses : int -> bool -> bool -> unitkill_all_subprocess signal override nogroup:
Sends a signal to potentially
all subprocesses. The signal is sent to a watched process if the process
still exists, and these two conditions hold both:not nogroup || pgid = 0: Processes with pgid > 0 are excluded
if nogroup is setkill_flag || override: A process needs to have
kill_flag set, or override is specifiedval killpg_all_subprocesses : int -> bool -> unitkillpg_all_subprocess signal override: Sends a signal to potentially
all subprocesses belonging to a process group (i.e. pgid>0).
. The signal is sent to a process group if there are still watched
subprocesses
belonging to the group, and if either the kill_flag of any of the
subprocesses process was set to true, or override is true.
Never throws an exception if the signal handler is installed.
val install_subprocess_handler : unit -> unitwaited for that are registered with
watch_subprocess.
The handler works both in the single-threaded and the multi-threaded
case. install_subprocess_handler can safely called several times.
The handler is installed every time the function is called, but the
required data structures are only initialized at the first call.
val register_subprocess_handler : unit -> unitNetsys_signal framework to manage the installation of
the SIGCHLD handler.
This is the preferred method of installing the SIGCHLD handler.
fork(): The subprocess handler uses
pipes for notification, and because of this it is sensitive to
unpredicted duplicates of the pipe descriptors. fork() duplicates
these pipe descriptors. If nothing is done about this issue, it
can happen that the notification does not work anymore as it relies
on detecting closed pipes.
If fork() is immediately followed by exec() (as it is done
to run subcommands), the problem does not occur, because the relevant
descriptors are closed at exec() time.
If fork() is used to start worker processes, however, we have
to be careful. The descriptors need to be closed, so that the
parent can continue to monitor subprocesses, and to allow the worker
processes to use this mechanism. This module defines post fork
handlers (see above), and a handler is automatically added that
cleans the descriptors up. All user code has to do is to call
run_post_fork_handlers immediately after fork() has spawned
the new child, from the new child. This completely resets
everything.
The subprocess handler and multi-threading: The handler has been
carefully designed, and works even in multi-threaded programs.
However, one should know that multi-threading and fork() do not
interact well with each other. Again, the problems do not occur
if fork() is followed by exec(). There is no solution for the
case that worker processes are started with fork(), though.
The (very generic) problem is that the state of mutexes and other
multi-threading primitives is not well-defined after a fork().
typelevel =Netlog.level
typesyslog_facility =[ `Authpriv
| `Cron
| `Daemon
| `Default
| `Ftp
| `Kern
| `Local0
| `Local1
| `Local2
| `Local3
| `Local4
| `Local5
| `Local6
| `Local7
| `Lpr
| `News
| `Syslog
| `User
| `Uucp ]
`User and `Local0 to `Local7 are
standard POSIX. If a facility is unavailable it is silently
substituted by `Local0. The value `Default leaves this unspecified.typesyslog_option =[ `Cons | `Ndelay | `Nowait | `Odelay | `Pid ]
`Cons: Fall back to console logging if syslog is unavailable`Ndelay: Open the connection immediately`Odelay: Open the connection at the first call syslog (default)`Nowait: Do not wait until it is ensured that the message is
sent`Pid: Log the PID with every messageval openlog : string option ->
syslog_option list -> syslog_facility -> unitopenlog ident options facility: Opens a log stream. ident is
prepended to every message if given (usually the program name).
The facility is the default facility for syslog calls.val syslog : syslog_facility -> level -> string -> unitsyslog facility level message: Logs message at level for
facilityval closelog : unit -> unitNetlog.current_logger to syslog facility, e.g.
Netlog.current_logger := Netsys_posix.syslog `User val fsync : Unix.file_descr -> unitval fdatasync : Unix.file_descr -> unitfsyncsock must be a connected
Unix domain socket.
The functionality backing this is non-standard but widely available.
Not yet implemented, but spec exists.
val have_fadvise : unit -> booltype advice =
| |
POSIX_FADV_NORMAL |
|||
| |
POSIX_FADV_SEQUENTIAL |
|||
| |
POSIX_FADV_RANDOM |
|||
| |
POSIX_FADV_NOREUSE |
|||
| |
POSIX_FADV_WILLNEED |
|||
| |
POSIX_FADV_DONTNEED |
|||
| |
FADV_NORMAL |
|||
| |
FADV_SEQUENTIAL |
|||
| |
FADV_RANDOM |
|||
| |
FADV_NOREUSE |
|||
| |
FADV_WILLNEED |
|||
| |
FADV_DONTNEED |
(* | Possible advices for fadvise. The names starting with "POSIX_" and the ones lacking the prefix have the same meaning. In new code, the names starting with "POSIX_" should be preferred (for better compaibility with other libraries). | *) |
val fadvise : Unix.file_descr -> int64 -> int64 -> advice -> unitval have_fallocate : unit -> boolval fallocate : Unix.file_descr -> int64 -> int64 -> unitval have_posix_shm : unit -> booltype shm_open_flag =
| |
SHM_O_RDONLY |
| |
SHM_O_RDWR |
| |
SHM_O_CREAT |
| |
SHM_O_EXCL |
| |
SHM_O_TRUNC |
val shm_open : string -> shm_open_flag list -> int -> Unix.file_descrThe open flags are interpreted as follows:
SHM_O_RDONLY: Open the object for read accessSHM_O_RDWR: Open the object for read-write accessSHM_O_CREAT: Create the object if it does not existSHM_O_EXCL: If SHM_O_CREAT was also specified, and a an object
with the given name already exists, return an error
(Unix.EEXIST).SHM_O_TRUNC: If the object already exists, truncate it to
zero bytesSHM_O_RDONLY or SHM_O_RDWR must be given.
On success, the function returns a file descriptor representing the
object. To access the object, one has to memory-map this file
use one of the map_file functions in the Bigarray
module, or in Netsys_mem). Use Unix.ftruncate to resize the object.
Note that it is unspecified whether this file pops up somewhere in the file system, and if so, where.
If a system error occurs, the function raises a Unix.Unix_error
exception.
val shm_unlink : string -> unitval shm_create : string -> int -> Unix.file_descr * stringlet (fd,name) = shm_create prefix size: Creates an shm object
with a unique name. The name has the passed prefix. The prefix
must start with "/" but must not contain any further "/". The object
has a length of size bytes. The object has a permissions 0o600
(independent of umask).val have_named_posix_semaphores : unit -> booltrue if named POSIX semaphores are supported on this systemval have_anon_posix_semaphores : unit -> booltrue if anonymous POSIX semaphores are supported on this
systemval have_posix_semaphores : unit -> booltrue if both kinds of semaphores are supported on this systemval sem_value_max : intmax_intval sem_size : intsizeof(sem_t))typesem_kind =[ `Anonymous | `Named ]
type 'sem_kind semaphore
typenamed_semaphore =[ `Named ] semaphore
typeanon_semaphore =[ `Anonymous ] semaphore
type sem_open_flag =
| |
SEM_O_CREAT |
| |
SEM_O_EXCL |
val sem_open : string ->
sem_open_flag list -> int -> int -> named_semaphoresem_open name flags mode init_value: Opens a named semaphore
which is optionally created. Sempahore names usually begin with
a slash followed by a single name component (not containing a
further slash).
Interpretation of flags:
SEM_O_CREAT: The semaphore is created if not yet existing.
The mode and init_value are interpreted if the creation
actually occurs. mode is the permission of the semaphore.
init_value is the (non-negative) initial value, up to
sem_value_max.SEM_O_EXCL: The semaphore is only opened if the semaphore
does not exist yet. Othwerwise an EEXIST error is returnedval sem_close : named_semaphore -> unitval sem_unlink : string -> unitval sem_create : string -> int -> named_semaphore * stringlet (sem,name) = sem_create prefix init_value: Creates
a new semaphore with a unique name. The name has the passed prefix.
The prefix must start with "/" but must not contain any further "/".
The semaphore is initialized with init_value. The object has
permissions 0o600 (modulo umask).val sem_init : Netsys_types.memory -> int -> bool -> int -> anon_semaphoresem_init mem pos pshared init_value: Initializes the memory
at position pos to pos + sem_size() - 1 as anonymous semaphore.
If pshared the semaphore is shared between processes.
init_value is the initial non-negative value (max is
sem_value_max.val sem_destroy : anon_semaphore -> unitval as_sem : Netsys_types.memory -> int -> anon_semaphoreas_sem mem pos: Interprets the memory at position pos
to pos + sem_size() - 1 as anonymous semaphore.
The memory region must already have been initialized.val sem_getvalue : 'kind semaphore -> intint, an EINVAL error is returned.
The returned value is non-negative - if the underlying POSIX function reports a negative value zero is returned instead.
Unavailable on MacOS.
val sem_post : 'kind semaphore -> unittype sem_wait_behavior =
| |
SEM_WAIT_BLOCK |
| |
SEM_WAIT_NONBLOCK |
val sem_wait : 'kind semaphore -> sem_wait_behavior -> unitSEM_WAIT_BLOCK is given, the function
waits until another process or thread posts. If SEM_WAIT_NONBLOCK
the error EAGAIN is returned.
sem_wait may be interrupted by signals.
type langinfo = {
|
nl_CODESET : |
(* | from LC_CTYPE: codeset name | *) |
|
nl_D_T_FMT : |
(* | from LC_TIME: string for formatting date and time | *) |
|
nl_D_FMT : |
(* | from LC_TIME: date format string | *) |
|
nl_T_FMT : |
(* | from LC_TIME: time format string | *) |
|
nl_T_FMT_AMPM : |
(* | from LC_TIME: a.m. or p.m. time format string | *) |
|
nl_AM_STR : |
(* | from LC_TIME: Ante Meridian affix | *) |
|
nl_PM_STR : |
(* | from LC_TIME: Post Meridian affix | *) |
|
nl_DAY_1 : |
(* | from LC_TIME: name of the first day of the week (for example, Sunday) | *) |
|
nl_DAY_2 : |
(* | from LC_TIME: name of the second day of the week (for example, Monday) | *) |
|
nl_DAY_3 : |
(* | from LC_TIME: name of the third day of the week (for example, Tuesday) | *) |
|
nl_DAY_4 : |
(* | from LC_TIME: name of the fourth day of the week (for example, Wednesday) | *) |
|
nl_DAY_5 : |
(* | from LC_TIME: name of the fifth day of the week (for example, Thursday) | *) |
|
nl_DAY_6 : |
(* | from LC_TIME: name of the sixth day of the week (for example, Friday) | *) |
|
nl_DAY_7 : |
(* | from LC_TIME: name of the seventh day of the week (for example, Saturday) | *) |
|
nl_ABDAY_1 : |
(* | from LC_TIME: abbreviated name of the first day of the week | *) |
|
nl_ABDAY_2 : |
(* | from LC_TIME: abbreviated name of the second day of the week | *) |
|
nl_ABDAY_3 : |
(* | from LC_TIME: abbreviated name of the third day of the week | *) |
|
nl_ABDAY_4 : |
(* | from LC_TIME: abbreviated name of the fourth day of the week | *) |
|
nl_ABDAY_5 : |
(* | from LC_TIME: abbreviated name of the fifth day of the week | *) |
|
nl_ABDAY_6 : |
(* | from LC_TIME: abbreviated name of the sixth day of the week | *) |
|
nl_ABDAY_7 : |
(* | from LC_TIME: abbreviated name of the seventh day of the week | *) |
|
nl_MON_1 : |
(* | from LC_TIME: name of the first month of the year | *) |
|
nl_MON_2 : |
(* | from LC_TIME: name of the second month | *) |
|
nl_MON_3 : |
(* | from LC_TIME: name of the third month | *) |
|
nl_MON_4 : |
(* | from LC_TIME: name of the fourth month | *) |
|
nl_MON_5 : |
(* | from LC_TIME: name of the fifth month | *) |
|
nl_MON_6 : |
(* | from LC_TIME: name of the sixth month | *) |
|
nl_MON_7 : |
(* | from LC_TIME: name of the seventh month | *) |
|
nl_MON_8 : |
(* | from LC_TIME: name of the eighth month | *) |
|
nl_MON_9 : |
(* | from LC_TIME: name of the ninth month | *) |
|
nl_MON_10 : |
(* | from LC_TIME: name of the tenth month | *) |
|
nl_MON_11 : |
(* | from LC_TIME: name of the eleventh month | *) |
|
nl_MON_12 : |
(* | from LC_TIME: name of the twelfth month | *) |
|
nl_ABMON_1 : |
(* | from LC_TIME: abbreviated name of the first month | *) |
|
nl_ABMON_2 : |
(* | from LC_TIME: abbreviated name of the second month | *) |
|
nl_ABMON_3 : |
(* | from LC_TIME: abbreviated name of the third month | *) |
|
nl_ABMON_4 : |
(* | from LC_TIME: abbreviated name of the fourth month | *) |
|
nl_ABMON_5 : |
(* | from LC_TIME: abbreviated name of the fifth month | *) |
|
nl_ABMON_6 : |
(* | from LC_TIME: abbreviated name of the sixth month | *) |
|
nl_ABMON_7 : |
(* | from LC_TIME: abbreviated name of the seventh month | *) |
|
nl_ABMON_8 : |
(* | from LC_TIME: abbreviated name of the eighth month | *) |
|
nl_ABMON_9 : |
(* | from LC_TIME: abbreviated name of the ninth month | *) |
|
nl_ABMON_10 : |
(* | from LC_TIME: abbreviated name of the tenth month | *) |
|
nl_ABMON_11 : |
(* | from LC_TIME: abbreviated name of the eleventh month | *) |
|
nl_ABMON_12 : |
(* | from LC_TIME: abbreviated name of the twelfth month | *) |
|
nl_ERA : |
(* | from LC_TIME: era description segments | *) |
|
nl_ERA_D_FMT : |
(* | from LC_TIME: era date format string | *) |
|
nl_ERA_D_T_FMT : |
(* | from LC_TIME: era date and time format string | *) |
|
nl_ERA_T_FMT : |
(* | from LC_TIME: era time format string | *) |
|
nl_ALT_DIGITS : |
(* | from LC_TIME: alternative symbols for digits | *) |
|
nl_RADIXCHAR : |
(* | from LC_NUMERIC: radix character | *) |
|
nl_THOUSEP : |
(* | from LC_NUMERIC: separator for thousands | *) |
|
nl_YESEXPR : |
(* | from LC_MESSAGES: affirmative response expression | *) |
|
nl_NOEXPR : |
(* | from LC_MESSAGES: negative response expression | *) |
|
nl_CRNCYSTR : |
(* | from LC_MONETARY: currency | *) |
val query_langinfo : string -> langinfoquery_langinfo locale: Temporarily sets the passed locale and
determines the language attributes. After that the orignal locale is
restored. Pass "" as locale to get the locale requested in the
environment.
The value for "" is cached.
typetimespec =float * int
(t,t_nanos): Specifies a time by a base time t to which the
nanoseconds t_nanos are added.
If this pair is returned by a function t will always be integral.
If a pair is passed to a function, it does not matter whether this
is the case or not, but using integral values for t ensure
maximum precision.
val nanosleep : timespec -> timespec Pervasives.ref -> unitnanosleep t t_rem: Sleeps for t seconds. The sleep can either be
finished, or the sleep can be interrupted by a signal. In the
latter case, the function will raise EÍNTR, and write to t_rem
the remaining seconds.type clock_id
type clock =
| |
CLOCK_REALTIME |
(* | A clock measuring wallclock time | *) |
| |
CLOCK_MONOTONIC |
(* | A clock measuring kernel time (non-settable). Optional, i.e. not supported by all OS | *) |
| |
CLOCK_ID of |
(* | A clock ID | *) |
val clock_gettime : clock -> timespecval clock_settime : clock -> timespec -> unitval clock_getres : clock -> timespecval clock_getcpuclockid : int -> clock_id
This function is not supported on all OS.
type posix_timer
type timer_expiration =
| |
TEXP_NONE |
| |
TEXP_EVENT of |
| |
TEXP_EVENT_CREATE |
| |
TEXP_SIGNAL of |
val have_posix_timer : unit -> bool
val timer_create : clock ->
timer_expiration -> posix_timerTEXP_NONE: no notificationTEXP_EVENT e: the not_event e is signalledTEXP_EVENT_CREATE: a special not_event is created for the timer.
(Get the event via timer_event, see below.)TEXP_SIGNAL n: the signal n is sent to the processTEXP_EVENT_CREATE is much faster on Linux than
TEXP_EVENT, because it can be avoided to start a new thread
whenever the timer expires. Instead, the timerfd machinery is used.
TEXP_EVENT and TEXP_EVENT_CREATE are only supported on systems
with pthreads.
val timer_settime : posix_timer ->
bool -> timespec -> timespec -> unittimer_settime tm abstime interval value:
If value=(0.0,0), the timer is stopped.
If value is a positive time, the timer is started (or the timeout
is changed if it is already started). If abstime, value is
interpreted as the absolute point in time of the expiration.
Otherwise value sets the number of seconds until the expiration.
If interval is positive, the started timer will repeat to expire
after this many seconds once it has expired for the first time.
If interval=(0.0,0), the timer is a one-shot timer.
val timer_gettime : posix_timer -> timespec(0.0,0)
if the timer is offval timer_delete : posix_timer -> unitval timer_event : posix_timer -> not_eventTEXP_EVENT and
TEXP_EVENT_CREATE.
Note that the latter type of event does not allow to call set_event.
timer_getoverrun.
Additional overruns can occur because of the further processing
of the notifications: The OCaml runtime can merge signals,
which would not be noticed by the kernel overrun counter,
and events can also be merged. The workaround is to use one-shot timers
with absolute expiration timestamps, and to check for overruns
manually. Once we have TEXP_NQ the issue is solved.
Per-process I/O priorities are currently only supported by the
CFQ I/O scheduler.
val have_ioprio : unit -> booltrue if the system call ioprio_get is supportedtype ioprio_target =
| |
Ioprio_process of |
(* | A single process | *) |
| |
Ioprio_pgrp of |
(* | A process group | *) |
| |
Ioprio_user of |
(* | All processes owned by this user | *) |
type ioprio =
| |
Noprio |
(* | I/O prioritization is unsupported by block layer | *) |
| |
Real_time of |
(* | 0..7 (higest..lowest prio) | *) |
| |
Best_effort of |
(* | 0..7 (higest..lowest prio) | *) |
| |
Idle |
val ioprio_get : ioprio_target -> ioprioESRCH will be raised.val ioprio_set : ioprio_target -> ioprio -> unitmodule Debug:sig..end