Eio_linux.Low_levelLow-level API for using uring directly.
type fd := Eio_unix.Fd.tThe size of the fixed buffer is set when calling Eio_linux.run, which attempts to allocate a fixed buffer. However, that may fail due to resource limits.
module Fixed : sig ... endFixed-buffer support.
val openat :
sw:Eio.Std.Switch.t ->
?seekable:bool ->
access:[ `R | `W | `RW ] ->
flags:Uring.Open_flags.t ->
perm:Unix.file_perm ->
dir_fd ->
string ->
fdopenat ~sw ~access ~flags ~perm dir path opens dir/path.
val openat2 :
sw:Eio.Std.Switch.t ->
?seekable:bool ->
access:[ `R | `W | `RW ] ->
flags:Uring.Open_flags.t ->
perm:Unix.file_perm ->
resolve:Uring.Resolve.t ->
?dir:fd ->
string ->
fdopenat2 ~sw ~access ~flags ~perm ~resolve ~dir path opens dir/path.
It provides full access to the resolve flags. See Uring.openat2 for details.
val read_upto : ?file_offset:Optint.Int63.t -> fd -> Fixed.chunk -> int -> intread_upto fd chunk len reads at most len bytes from fd, returning as soon as some data is available.
val read_exactly :
?file_offset:Optint.Int63.t ->
fd ->
Fixed.chunk ->
int ->
unitread_exactly fd chunk len reads exactly len bytes from fd, performing multiple read operations if necessary.
val readv : ?file_offset:Optint.Int63.t -> fd -> Cstruct.t list -> intreadv is like read_upto but can read into any cstruct(s), not just chunks of the pre-shared buffer.
If multiple buffers are given, they are filled in order.
val write : ?file_offset:Optint.Int63.t -> fd -> Fixed.chunk -> int -> unitwrite fd buf len writes exactly len bytes from buf to fd.
It blocks until the OS confirms the write is done, and resubmits automatically if the OS doesn't write all of it at once.
val writev : ?file_offset:Optint.Int63.t -> fd -> Cstruct.t list -> unitwritev is like write but can write from any cstruct(s), not just chunks of the pre-shared buffer.
If multiple buffers are given, they are sent in order. It will make multiple OS calls if the OS doesn't write all of it at once.
val writev_single : ?file_offset:Optint.Int63.t -> fd -> Cstruct.t list -> intwritev_single is like writev but only performs a single write operation. It returns the number of bytes written, which may be smaller than the requested amount.
splice src ~dst ~len attempts to copy up to len bytes of data from src to dst.
val connect : fd -> Unix.sockaddr -> unitconnect fd addr attempts to connect socket fd to addr.
val await_readable : fd -> unitawait_readable fd blocks until fd is readable (or has an error).
val await_writable : fd -> unitawait_writable fd blocks until fd is writable (or has an error).
val fstat : fd -> Eio.File.Stat.tLike Unix.LargeFile.fstat.
val eio_of_statx : Uring.Statx.t -> Eio.File.Stat.teio_of_statx x converts a statx buffer to a more portable stat record. The buffer should have been filled using at least Uring.Statx.Mask.basic_stats.
val statx :
mask:Uring.Statx.Mask.t ->
follow:bool ->
dir_fd ->
string ->
Uring.Statx.t ->
unitstatx ~mask ~follow dir path buf stats dir / path.
The results are written to buf. If follow = true and the item is a symlink, information is reported about the target of the link. Otherwise, information about the symlink itself is returned.
val mkdir : perm:int -> dir_fd -> string -> unitmkdir ~perm dir path creates directory dir / path.
val read_link : dir_fd -> string -> stringread_link dir path reads the target of symlink dir / path.
val unlink : rmdir:bool -> dir_fd -> string -> unitunlink ~rmdir dir path removes directory entry dir / path.
If rmdir = true then the target must be a directory. Otherwise, it must not be a directory.
rename old_dir old_path new_dir new_path renames old_dir / old_path as new_dir / new_path.
val symlink : link_to:string -> dir_fd -> string -> unitsymlink ~link_to dir path creates a new symlink at dir / path pointing to link_to.
val chmod : follow:bool -> mode:int -> dir_fd -> string -> unitchmod ~follow ~mode dir path changes the file mode bits of dir / path.
val chown : follow:bool -> ?uid:int64 -> ?gid:int64 -> dir_fd -> string -> unitchown ~follow ~uid ~gid dir path changes the ownership of dir / path to uid, gid.
If follow = true and dir / path is a symlink, then the ownership of the target is changed. If it is false then the ownership of the symlink itself is changed.
val pipe : sw:Eio.Std.Switch.t -> fd * fdpipe ~sw returns a pair r, w with the readable and writeable ends of a new pipe.
val read_dir : fd -> string listread_dir dir reads all directory entries from dir. The entries are not returned in any particular order (not even necessarily the order in which Linux returns them).
val read_some_dir : fd -> (Eio.File.Stat.kind * string) listread_some_dir dir reads some of the directory entries from dir, including their kind. The entries are not returned in any particular order (not even necessarily the order in which Linux returns them).
val lseek : fd -> Optint.Int63.t -> [ `Set | `Cur | `End ] -> Optint.Int63.tSet and/or get the current file position.
Like Unix.lseek.
val fsync : fd -> unitFlush file buffers to disk.
Like Unix.fsync.
val fdatasync : fd -> unitFlush file data to disk.
Like fsync, but does not wait for metadata that is not needed to read the data back. The aim is to reduce disk activity for callers that do not require all metadata to be synchronized with the disk.
val ftruncate : fd -> Optint.Int63.t -> unitSet the length of a file.
Like Unix.ftruncate.
val fallocate :
?mode:Uring.Fallocate_flags.t ->
fd ->
off:Optint.Int63.t ->
len:Optint.Int63.t ->
unitfallocate fd ~off ~len manipulates the disk space allocated for the len bytes of fd starting at off (the fallocate(2) call).
With the default mode (the empty set of flags) this allocates the region as for posix_fallocate(3), extending the file's size if needed. See Uring.Fallocate_flags for other modes, such as punching holes.
val socket :
sw:Eio.Std.Switch.t ->
Unix.socket_domain ->
Unix.socket_type ->
int ->
fdsocket ~sw domain ty protocol creates a new socket, like Unix.socket.
The new socket has the close-on-exec flag set and is attached to sw. On Linux >= 5.19 this uses io_uring and on older kernels it falls back to a socket(2) call.
val bind : fd -> Unix.sockaddr -> unitbind fd addr binds socket fd to addr, like Unix.bind.
On Linux >= 6.11 this uses io_uring and on older kernels falls back to a bind(2) call.
val listen : fd -> int -> unitlisten fd backlog marks socket fd as accepting connections, like Unix.listen.
On Linux >= 6.11 this uses io_uring and on older kernels falls back to a listen(2) call.
val accept : sw:Eio.Std.Switch.t -> fd -> fd * Unix.sockaddraccept ~sw t blocks until a new connection is received on listening socket t.
It returns the new connection and the address of the connecting peer. The new connection has the close-on-exec flag set automatically. The new connection is attached to sw and will be closed when that finishes, if not already closed manually by then.
val shutdown : fd -> Unix.shutdown_command -> unitLike Unix.shutdown.
send_msg socket bufs is like writev socket bufs, but also allows setting the destination address (for unconnected sockets) and attaching FDs (for Unix-domain sockets).
val recv_msg : fd -> Cstruct.t list -> Uring.Sockaddr.t * intrecv_msg socket bufs is like readv socket bufs but also returns the address of the sender.
val recv_msg_with_fds :
sw:Eio.Std.Switch.t ->
max_fds:int ->
fd ->
Cstruct.t list ->
Uring.Sockaddr.t * int * fd listrecv_msg_with_fds is like recv_msg but also allows receiving up to max_fds file descriptors (sent using SCM_RIGHTS over a Unix domain socket).
val setsockopt : fd -> 'a Eio.Net.Sockopt.t -> 'a -> unitsetsockopt fd opt v sets socket option opt to value v on file descriptor fd.
val getsockopt : fd -> 'a Eio.Net.Sockopt.t -> 'agetsockopt fd opt gets the value of socket option opt on file descriptor fd.
getrandom buf fills buf with random bytes.
It uses Linux's getrandom call, which is like reading from /dev/urandom except that it will block (the whole domain) if used at early boot when the random system hasn't been initialised yet.
val getaddrinfo : service:string -> string -> Eio.Net.Sockaddr.t listgetaddrinfo host returns a list of IP addresses for host. host is either a domain name or an ipaddress.
module Process : sig ... end