Module Async_unix__.Unix_syscalls
module Syscall_result = Core.Unix.Syscall_result
module Exit = Core.Unix.Exit
module Exit_or_signal = Core.Unix.Exit_or_signal
module Exit_or_signal_or_stop = Core.Unix.Exit_or_signal_or_stop
val system : string -> Exit_or_signal.t Async_unix__.Import.Deferred.t
val system_exn : string -> unit Async_unix__.Import.Deferred.t
val getpid : unit -> Core.Pid.t
val getppid : unit -> Core.Pid.t option
val getppid_exn : unit -> Core.Pid.t
val this_process_became_child_of_init : ?poll_delay:Core.Time.Span.t -> unit -> unit Async_unix__.Import.Deferred.t
this_process_became_child_of_init
returns a deferred that becomes determined when the current process becomes a child ofinit(8)
. This is useful for determining whether one's parent has died, because in that caseinit
will become one's parent.See
Linux_ext.pr_set_pdeathsig : Signal.t -> unit
for a related way to get information about parent death.?poll_delay
controls how often to check.
val nice : int -> int
val cores : (unit -> int Async_unix__.Import.Deferred.t) Core.Or_error.t
cores ()
Returns the number of cores.
type open_flag
=[
|
`Rdonly
|
`Wronly
|
`Rdwr
|
`Nonblock
|
`Append
|
`Creat
|
`Trunc
|
`Excl
|
`Noctty
|
`Dsync
|
`Sync
|
`Rsync
]
type file_perm
= int
val openfile : ?perm:file_perm -> string -> mode:open_flag list -> Async_unix.Fd.t Async_unix__.Import.Deferred.t
module Lock_mode : sig ... end
module Lock_mechanism : sig ... end
module Lock : sig ... end
val with_file : ?lock:Lock.t -> ?perm:file_perm -> string -> mode:open_flag list -> f:(Async_unix.Fd.t -> 'a Async_unix__.Import.Deferred.t) -> 'a Async_unix__.Import.Deferred.t
with_file file ~mode ~perm ~f
opensfile
, and appliesf
to the resulting file descriptor. When the result off
becomes determined, it closes the descriptor and returns the result off
.If
lock
is supplied, then the file descriptor is locked before callingf
with the specifiedlock_mechanism
. Note that it is not unlocked before close, which might be significant if this file descriptior is held elsewhere (e.g., by fork() or dup()).
module Open_flags = Core.Unix.Open_flags
val fcntl_getfl : Async_unix.Fd.t -> Open_flags.t Async_unix__.Import.Deferred.t
fcntl_getfl
andfcntl_setf
are deferred wrappers around the corresponding functions inCore.Unix
for accessing the open-file-descriptor table.
val fcntl_setfl : Async_unix.Fd.t -> Open_flags.t -> unit Async_unix__.Import.Deferred.t
include module type of Async_unix.Fd.Close
type socket_handling
=
|
Shutdown_socket
|
Do_not_shutdown_socket
type file_descriptor_handling
=
|
Close_file_descriptor of socket_handling
|
Do_not_close_file_descriptor
val close : ?file_descriptor_handling:file_descriptor_handling -> Async_unix.Fd.t -> unit Async_unix__.Import.Deferred.t
close t
prevents further use oft
, and makesshutdown()
andclose()
system calls ont
's underlying file descriptor according to thefile_descriptor_handling
argument and whether or nott
is a socket, i.e.,kind t = Socket `Active
:| file_descriptor_handling | shutdown() | close() | |----------------------------------------------+------------+---------| | Do_not_close_file_descriptor | no | no | | Close_file_descriptor Shutdown_socket | if socket | yes | | Close_file_descriptor Do_not_shutdown_socket | no | yes |
The result of
close
becomes determined once the system calls complete. It is OK to callclose
multiple times on the samet
; calls subsequent to the initial call will have no effect, but will return the same deferred as the original call.
val lseek : Async_unix.Fd.t -> int64 -> mode:[< `Set | `Cur | `End ] -> int64 Async_unix__.Import.Deferred.t
val truncate : string -> len:int64 -> unit Async_unix__.Import.Deferred.t
val ftruncate : Async_unix.Fd.t -> len:int64 -> unit Async_unix__.Import.Deferred.t
val fsync : Async_unix.Fd.t -> unit Async_unix__.Import.Deferred.t
val fdatasync : Async_unix.Fd.t -> unit Async_unix__.Import.Deferred.t
val sync : unit -> unit Async_unix__.Import.Deferred.t
val lockf : ?len:Core.Int64.t -> Async_unix.Fd.t -> Lock_mode.t -> unit Async_unix__.Import.Deferred.t
lockf fd lock_mode ?len
locks the section of the open filefd
specified by the current file position andlen
(see man lockf). It returns when the lock has been acquired. It raises iffd
is closed.Note that, despite the name, this function does not call the UNIX lockf() system call; rather it calls fcntl() with F_SETLKW
val try_lockf : ?len:Core.Int64.t -> Async_unix.Fd.t -> Lock_mode.t -> bool
try_lockf fd lock_mode ?len
attempts to lock the section of the open filefd
specified by the current file position andlen
(see man lockf). It returnstrue
if it acquired the lock. It raises iffd
is closed.Note that, despite the name, this function does not call the UNIX lockf() system call; rather it calls fcntl() with F_SETLK
val test_lockf : ?len:Core.Int64.t -> Async_unix.Fd.t -> bool
test_lockf fd ?len
checks the lock on section of the open filefd
specified by the current file position andlen
. If the section is unlocked or locked by this process, it returns true, else it returns false. It raises iffd
is closed.Note that, despite the name, this function does not call the UNIX lockf() system call; rather it calls fcntl() with F_GETLK
val unlockf : ?len:Core.Int64.t -> Async_unix.Fd.t -> unit
unlockf fd ?len
unlocks the section of the open filefd
specified by the current file position andlen
. It raises iffd
is closed.Note that, despite the name, this function does not call the UNIX lockf() system call; rather it calls fcntl() with F_UNLCK
val flock : Async_unix.Fd.t -> Lock_mode.t -> unit Async_unix__.Import.Deferred.t
flock fd lock_mode
locks the open filefd
(see man 2 flock). It returns when the lock has been acquired. It raises iffd
is closed.
val try_flock : Async_unix.Fd.t -> Lock_mode.t -> bool
try_flock fd lock_mode
attempts to lock the open filefd
(see man 2 flock). It returnstrue
if it acquired the lock orfalse
if a conflicting lock was already present. It raises iffd
is closed.
val funlock : Async_unix.Fd.t -> unit
funlock fd
unlocks the open filefd
(seeman 2 flock
). It raises iffd
is closed.
module File_kind : sig ... end
module Stats : sig ... end
val fstat : Async_unix.Fd.t -> Stats.t Async_unix__.Import.Deferred.t
val stat : string -> Stats.t Async_unix__.Import.Deferred.t
val lstat : string -> Stats.t Async_unix__.Import.Deferred.t
val isatty : Async_unix.Fd.t -> bool Async_unix__.Import.Deferred.t
val unlink : string -> unit Async_unix__.Import.Deferred.t
val remove : string -> unit Async_unix__.Import.Deferred.t
val rename : src:string -> dst:string -> unit Async_unix__.Import.Deferred.t
val link : ?force:bool -> target:string -> link_name:string -> unit -> unit Async_unix__.Import.Deferred.t
val chmod : string -> perm:file_perm -> unit Async_unix__.Import.Deferred.t
val fchmod : Async_unix.Fd.t -> perm:file_perm -> unit Async_unix__.Import.Deferred.t
val chown : string -> uid:int -> gid:int -> unit Async_unix__.Import.Deferred.t
val fchown : Async_unix.Fd.t -> uid:int -> gid:int -> unit Async_unix__.Import.Deferred.t
val access : string -> [ `Read | `Write | `Exec | `Exists ] list -> (unit, exn) Core.Result.t Async_unix__.Import.Deferred.t
val access_exn : string -> [ `Read | `Write | `Exec | `Exists ] list -> unit Async_unix__.Import.Deferred.t
val set_close_on_exec : Async_unix.Fd.t -> unit
val clear_close_on_exec : Async_unix.Fd.t -> unit
val mkdir : ?p:unit -> ?perm:file_perm -> string -> unit Async_unix__.Import.Deferred.t
val rmdir : string -> unit Async_unix__.Import.Deferred.t
val chdir : string -> unit Async_unix__.Import.Deferred.t
val getcwd : unit -> string Async_unix__.Import.Deferred.t
val chroot : string -> unit Async_unix__.Import.Deferred.t
type dir_handle
= Core.Unix.dir_handle
val opendir : string -> dir_handle Async_unix__.Import.Deferred.t
val readdir_opt : dir_handle -> string option Async_unix__.Import.Deferred.t
readdir_opt dir_handle
returns the next directory member, orNone
when there are no more directory members to return.
val rewinddir : dir_handle -> unit Async_unix__.Import.Deferred.t
val closedir : dir_handle -> unit Async_unix__.Import.Deferred.t
val pipe : Core.Info.t -> ([ `Reader of Async_unix.Fd.t ] * [ `Writer of Async_unix.Fd.t ]) Async_unix__.Import.Deferred.t
The
info
supplied to pipe is debugging information that will be included in the returnedFd
s.
val mkfifo : ?perm:file_perm -> string -> unit Async_unix__.Import.Deferred.t
Create a named pipe with the given permissions.
val symlink : target:string -> link_name:string -> unit Async_unix__.Import.Deferred.t
val readlink : string -> string Async_unix__.Import.Deferred.t
val mkstemp : string -> (string * Async_unix.Fd.t) Async_unix__.Import.Deferred.t
mkstemp prefix
creates and opens a unique temporary file withprefix
, automatically appending a suffix of six random characters to make the name unique. Unlike C'smkstemp
,prefix
should not include six X's at the end.- raises Unix_error
on errors.
val mkdtemp : string -> string Async_unix__.Import.Deferred.t
val getgrouplist : string -> int -> int array Async_unix__.Import.Deferred.t
type process_times
= Core.Unix.process_times
=
{
}
Time functions.
val times : unit -> process_times
type tm
= Core.Unix.tm
=
{
}
val time : unit -> float
val gettimeofday : unit -> float
val gmtime : float -> tm
val localtime : float -> tm
val mktime : tm -> float * tm
val utimes : string -> access:float -> modif:float -> unit Async_unix__.Import.Deferred.t
type env
= Core.Unix.env
val sexp_of_env : env -> Ppx_sexp_conv_lib.Sexp.t
val env_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> env
val environment : unit -> string array
val getenv : string -> string option
val getenv_exn : string -> string
val unsafe_getenv : string -> string option
val unsafe_getenv_exn : string -> string
val putenv : key:string -> data:string -> unit
val unsetenv : string -> unit
val fork_exec : prog:string -> argv:string list -> ?use_path:bool -> ?env:[ env | `Replace_raw of string list ] -> unit -> Core.Pid.t Async_unix__.Import.Deferred.t
fork_exec ~prog ~argv ?path ?env
forks and execsprog
withargv
, and returns the child pid. Ifuse_path = true
(the default) andprog
doesn't contain a slash, thenfork_exec
searches the PATH environment variable forprog
. Ifenv
is supplied, it specifies the environment whenprog
is executed.If
env
contains multiple bindings for the same variable, the last takes precedence. In the case of`Extend
, bindings inenv
take precedence over the existing environment. SeeUnix
.exec.
type wait_on
=[
|
`Any
|
`Group of Core.Pid.t
|
`My_group
|
`Pid of Core.Pid.t
]
val sexp_of_wait_on : wait_on -> Ppx_sexp_conv_lib.Sexp.t
val wait_on_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> wait_on
val __wait_on_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> wait_on
val wait : wait_on -> (Core.Pid.t * Exit_or_signal.t) Async_unix__.Import.Deferred.t
val wait_nohang : wait_on -> (Core.Pid.t * Exit_or_signal.t) option
val wait_untraced : wait_on -> (Core.Pid.t * Exit_or_signal_or_stop.t) Async_unix__.Import.Deferred.t
val wait_nohang_untraced : wait_on -> (Core.Pid.t * Exit_or_signal_or_stop.t) option
val waitpid : Core.Pid.t -> Exit_or_signal.t Async_unix__.Import.Deferred.t
waitpid pid
returns a deferred that becomes determined with the child's exit status, when the child process with process idpid
exits.waitpid_exn
is likewaitpid
, except the result only becomes determined if the child exits with status zero; it raises if the child terminates in any other way.
val waitpid_prompt : Core.Pid.t -> Exit_or_signal.t Async_unix__.Import.Deferred.t
Same as
waitpid
, but guarantees that the resultingDeferred
is determined in the same async job as thewait
system call, so that it's safe to keep using thepid
if the deferred is not determined.
val waitpid_exn : Core.Pid.t -> unit Async_unix__.Import.Deferred.t
module Inet_addr : sig ... end
module Cidr = Core.Unix.Cidr
module Protocol_family : sig ... end
val socketpair : unit -> Async_unix.Fd.t * Async_unix.Fd.t
module Socket : sig ... end
val bind_to_interface_exn : (Async_unix.Fd.t -> Linux_ext.Bound_to_interface.t -> unit) Core.Or_error.t
module Host : sig ... end
type socket_domain
= Core.Unix.socket_domain
=
|
PF_UNIX
|
PF_INET
|
PF_INET6
val bin_shape_socket_domain : Bin_prot.Shape.t
val bin_size_socket_domain : socket_domain Bin_prot.Size.sizer
val bin_write_socket_domain : socket_domain Bin_prot.Write.writer
val bin_writer_socket_domain : socket_domain Bin_prot.Type_class.writer
val bin_read_socket_domain : socket_domain Bin_prot.Read.reader
val __bin_read_socket_domain__ : (int -> socket_domain) Bin_prot.Read.reader
val bin_reader_socket_domain : socket_domain Bin_prot.Type_class.reader
val bin_socket_domain : socket_domain Bin_prot.Type_class.t
val compare_socket_domain : socket_domain -> socket_domain -> int
val hash_fold_socket_domain : Base.Hash.state -> socket_domain -> Base.Hash.state
val hash_socket_domain : socket_domain -> Base.Hash.hash_value
val sexp_of_socket_domain : socket_domain -> Ppx_sexp_conv_lib.Sexp.t
val socket_domain_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> socket_domain
type socket_type
= Core.Unix.socket_type
=
|
SOCK_STREAM
|
SOCK_DGRAM
|
SOCK_RAW
|
SOCK_SEQPACKET
val bin_shape_socket_type : Bin_prot.Shape.t
val bin_size_socket_type : socket_type Bin_prot.Size.sizer
val bin_write_socket_type : socket_type Bin_prot.Write.writer
val bin_writer_socket_type : socket_type Bin_prot.Type_class.writer
val bin_read_socket_type : socket_type Bin_prot.Read.reader
val __bin_read_socket_type__ : (int -> socket_type) Bin_prot.Read.reader
val bin_reader_socket_type : socket_type Bin_prot.Type_class.reader
val bin_socket_type : socket_type Bin_prot.Type_class.t
val compare_socket_type : socket_type -> socket_type -> int
val hash_fold_socket_type : Base.Hash.state -> socket_type -> Base.Hash.state
val hash_socket_type : socket_type -> Base.Hash.hash_value
val sexp_of_socket_type : socket_type -> Ppx_sexp_conv_lib.Sexp.t
val socket_type_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> socket_type
type sockaddr
= Core.Unix.sockaddr
=
|
ADDR_UNIX of string
|
ADDR_INET of Inet_addr.t * int
val bin_shape_sockaddr : Bin_prot.Shape.t
val bin_size_sockaddr : sockaddr Bin_prot.Size.sizer
val bin_write_sockaddr : sockaddr Bin_prot.Write.writer
val bin_writer_sockaddr : sockaddr Bin_prot.Type_class.writer
val bin_read_sockaddr : sockaddr Bin_prot.Read.reader
val __bin_read_sockaddr__ : (int -> sockaddr) Bin_prot.Read.reader
val bin_reader_sockaddr : sockaddr Bin_prot.Type_class.reader
val bin_sockaddr : sockaddr Bin_prot.Type_class.t
val compare_sockaddr : sockaddr -> sockaddr -> int
val sexp_of_sockaddr : sockaddr -> Ppx_sexp_conv_lib.Sexp.t
type sockaddr_blocking_sexp
= sockaddr
sockaddr_blocking_sexp
is likesockaddr
, withof_sexp
that performs DNS lookup to resolveInet_addr.t
.
val bin_shape_sockaddr_blocking_sexp : Bin_prot.Shape.t
val bin_size_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Size.sizer
val bin_write_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Write.writer
val bin_writer_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Type_class.writer
val bin_read_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Read.reader
val __bin_read_sockaddr_blocking_sexp__ : (int -> sockaddr_blocking_sexp) Bin_prot.Read.reader
val bin_reader_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Type_class.reader
val bin_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Type_class.t
val sexp_of_sockaddr_blocking_sexp : sockaddr_blocking_sexp -> Ppx_sexp_conv_lib.Sexp.t
val sockaddr_blocking_sexp_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> sockaddr_blocking_sexp
module Addr_info : sig ... end
module Name_info : sig ... end
val gethostname : unit -> string
val getuid : unit -> int
val geteuid : unit -> int
val getgid : unit -> int
val getegid : unit -> int
val setuid : int -> unit
module Error = Core.Unix.Error
exception
Unix_error of Error.t * string * string
module Terminal_io : sig ... end
module Passwd : sig ... end
Structure of entries in the
passwd
database.
module Group : sig ... end
Structure of entries in the
groups
database.
module Ifaddr = Core.Unix.Ifaddr
val getifaddrs : unit -> Ifaddr.t list Async_unix__.Import.Deferred.t
Gets the information using the socket-based netlink interface, which can block; see https://www.infradead.org/~tgr/libnl/doc/core.html.
val getlogin : unit -> string Async_unix__.Import.Deferred.t
Returns the login name of the user executing the process.
This returns a deferred because the username may need to be looked up in what is essentially a database elsewhere on the network (winbound user, or NIS).
val wordexp : (?flags:[ `No_cmd | `Show_err | `Undef ] list -> string -> string array Async_unix__.Import.Deferred.t) Core.Or_error.t
module Private : sig ... end