Rustix Uring

https://docs.rs/rustix-uring/0.6.0/rustix_uring/
Admin
Rustix Uring is a Rust library that provides safe bindings to the Linux io_uring interface for...
Tokens:18,073
Snippets:123
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Register Restrictions

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Permanently installs a feature allowlist. Once called, attempting to perform an operation not on the allowlist will fail.

```APIDOC
## POST /register/restrictions

### Description
Permanently install a feature allowlist. Once this has been called, attempting to perform an operation not on the allowlist will fail with `-EACCES`. This can only be called once.

### Method
POST

### Endpoint
/register/restrictions

### Parameters
#### Request Body
- **res** ([Restriction]) - Required - A mutable slice of `Restriction` objects defining the allowlist.

### Request Example
```json
{
  "res": [
    {"opcode": 1, "bits": 0},
    {"opcode": 2, "bits": 0}
  ]
}
```

### Response
#### Success Response (200)
- **Result** (Result<()>) - Indicates success or failure of the operation.
```

--------------------------------

### Rust: Register Files for io_uring

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Replaces or updates files in the registered file set with new ones. It supports turning sparse entries into real ones, removing existing entries, or replacing them. The `offset` parameter specifies the starting position for updates. This operation can also be performed asynchronously.

```rust
pub fn register_files_update(&self, offset: u32, fds: &[RawFd]) -> Result<()>
```

--------------------------------

### Rust: Register io_uring Probe for Supported Opcodes

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Fills a `Probe` object with information about the opcodes supported by io_uring on the current kernel. This allows developers to check for the availability of specific operations before attempting to use them. An example demonstrates how to check if reading is supported.

```rust
pub fn register_probe(&self, probe: &mut Probe) -> Result<()>
```

```rust
let io_uring = rustix_uring::IoUring::new(1)?;
let mut probe = rustix_uring::Probe::new();
io_uring.submitter().register_probe(&mut probe)?;

if probe.is_supported(rustix_uring::opcode::Read::CODE) {
    println!("Reading is supported!");
}
```

--------------------------------

### Rust: Register io_uring Restrictions (Feature Allowlist)

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Permanently installs a feature allowlist for io_uring operations. Once called, any operation not on the allowlist will fail with `-EACCES`. This function can only be called once to prevent untrusted code from modifying restrictions.

```rust
pub fn register_restrictions(&self, res: &mut [Restriction]) -> Result<()>
```

--------------------------------

### Flags Type Definition and Basic Operations (Rust)

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/cqueue/struct

Defines the `Flags` type and its associated constants and methods. This includes the underlying bits type, methods to get and set bits, create empty or all-set flags, and check for unknown bits.

```rust
impl Flags for Flags {
    const FLAGS: &'static [Flag<Flags>] = ...;
    type Bits = u32;

    fn bits(&self) -> u32 { ... }
    fn from_bits_retain(bits: u32) -> Flags { ... }
    fn empty() -> Self { ... }
    fn all() -> Self { ... }
    fn contains_unknown_bits(&self) -> bool { ... }
    fn from_bits(bits: Self::Bits) -> Option<Self> { ... }
    fn from_bits_truncate(bits: Self::Bits) -> Self { ... }
    fn from_name(name: &str) -> Option<Self> { ... }
    fn iter(&self) -> Iter<Self> { ... }
    fn iter_names(&self) -> IterNames<Self> { ... }
    fn is_empty(&self) -> bool { ... }
    fn is_all(&self) -> bool { ... }
    fn intersects(&self, other: Self) -> bool { ... }
    fn contains(&self, other: Self) -> bool { ... }
    fn truncate(&mut self) { ... }
    fn insert(&mut self, other: Self) { ... }
    fn remove(&mut self, other: Self) { ... }
    fn toggle(&mut self, other: Self) { ... }
    fn set(&mut self, other: Self, value: bool) { ... }
    fn clear(&mut self) { ... }
    fn intersection(self, other: Self) -> Self { ... }
    fn union(self, other: Self) -> Self { ... }
    fn difference(self, other: Self) -> Self { ... }
    fn symmetric_difference(self, other: Self) -> Self { ... }
    fn complement(self) -> Self { ... }
}
```

--------------------------------

### Register IOWQ Max Workers

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Gets and/or sets the limit for the number of io_uring worker threads per NUMA node.

```APIDOC
## POST /register/iowq_max_workers

### Description
Get and/or set the limit for number of io_uring worker threads per NUMA node. `max[0]` holds the limit for bounded workers, which process I/O operations expected to be bound in time, that is I/O on regular files or block devices. While `max[1]` holds the limit for unbounded workers, which carry out I/O operations that can never complete, for instance I/O on sockets. Passing `0` does not change the current limit. Returns previous limits on success.

### Method
POST

### Endpoint
/register/iowq_max_workers

### Parameters
#### Request Body
- **max** ([u32; 2]) - Optional - An array of two u32 values. `max[0]` for bounded workers, `max[1]` for unbounded workers. Passing `0` does not change the current limit.

### Request Example
```json
{
  "max": [8, 16]
}
```

### Response
#### Success Response (200)
- **previous_limits** ([u32; 2]) - The previous limits for bounded and unbounded workers.
```

--------------------------------

### Rust: Get/Set io_uring Max Worker Threads per NUMA Node

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Allows getting and/or setting the limit for the number of io_uring worker threads per NUMA node. `max[0]` controls bounded workers (e.g., regular files), and `max[1]` controls unbounded workers (e.g., sockets). Passing `0` leaves the limit unchanged. Returns previous limits.

```rust
pub fn register_iowq_max_workers(&self, max: &mut [u32; 2]) -> Result<()>
```

--------------------------------

### rustix-uring Structs

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/all

Documentation for the core structs used in rustix-uring, including Builder, Errno, IoUring, Parameters, Submitter, and various opcode and queue-related structs.

```APIDOC
## Structs

### `Builder`
Represents a builder for configuring and creating `IoUring` instances.

### `Errno`
An enum representing different error codes that can be returned by io_uring operations.

### `IoUring`
The main structure for interacting with the io_uring interface. It allows submission of operations and retrieval of completions.

### `Parameters`
Contains parameters for configuring the io_uring instance, such as ring size and feature flags.

### `Submitter`
A component of `IoUring` responsible for submitting new operations to the kernel.

### `cqueue::CompletionQueue`
Represents the completion queue where completed operations are reported.

### `cqueue::Entry`
A struct representing a single entry in the completion queue.

### `cqueue::Entry32`
A 32-bit representation of a completion queue entry.

### `cqueue::Flags`
Flags associated with completion queue entries.

### `opcode::Accept`
Represents an `accept` operation for socket I/O.

### `opcode::AcceptMulti`
Represents an `accept_multi` operation.

### `opcode::AsyncCancel`
Represents an `async_cancel` operation to cancel a previously submitted request.

### `opcode::AsyncCancel2`
Represents an `async_cancel2` operation.

### `opcode::Close`
Represents a `close` operation for file descriptors.

### `opcode::Connect`
Represents a `connect` operation for socket I/O.

### `opcode::EpollCtl`
Represents an `epoll_ctl` operation.

### `opcode::Fadvise`
Represents an `fadvise` operation for file advisory information.

### `opcode::Fallocate`
Represents an `fallocate` operation for pre-allocating space for a file.

### `opcode::FilesUpdate`
Represents a `files_update` operation for managing file descriptors in the ring.

### `opcode::FixedFdInstall`
Represents a `fixed_fd_install` operation to register a file descriptor for fixed usage.

### `opcode::Fsync`
Represents an `fsync` operation to flush file data to storage.

### `opcode::Ftruncate`
Represents an `ftruncate` operation to truncate or extend a file.

### `opcode::FutexWait`
Represents a `futex_wait` operation for efficient userspace synchronization.

### `opcode::FutexWaitV`
Represents a `futex_waitv` operation.

### `opcode::FutexWake`
Represents a `futex_wake` operation.

### `opcode::LinkAt`
Represents a `linkat` operation.

### `opcode::LinkTimeout`
Represents a `link_timeout` operation.

### `opcode::Madvise`
Represents a `madvise` operation for memory advice.

### `opcode::MkDirAt`
Represents a `mkdirat` operation.

### `opcode::MsgRingData`
Represents a `msg_ring_data` operation.

### `opcode::MsgRingSendFd`
Represents a `msg_ring_send_fd` operation.

### `opcode::Nop`
Represents a `nop` (no operation) request.

### `opcode::OpenAt`
Represents an `openat` operation for opening files relative to a directory.

### `opcode::OpenAt2`
Represents an `openat2` operation.

### `opcode::PollAdd`
Represents a `poll_add` operation for registering for I/O events.

### `opcode::PollRemove`
Represents a `poll_remove` operation to unregister for I/O events.

### `opcode::ProvideBuffers`
Represents a `provide_buffers` operation to supply buffers to the ring.

### `opcode::Read`
Represents a `read` operation for reading data from a file descriptor.

### `opcode::ReadFixed`
Represents a `read_fixed` operation with a pre-allocated buffer.

### `opcode::Readv`
Represents a `readv` operation for reading scattered data.

### `opcode::Recv`
Represents a `recv` operation for receiving data from a socket.

### `opcode::RecvBundle`
Represents a `recv_bundle` operation.

### `opcode::RecvMsg`
Represents a `recvmsg` operation for receiving messages.

### `opcode::RecvMsgMulti`
Represents a `recvmsg_multi` operation.

### `opcode::RecvMulti`
Represents a `recv_multi` operation.

### `opcode::RecvMultiBundle`
Represents a `recv_multi_bundle` operation.

### `opcode::RemoveBuffers`
Represents a `remove_buffers` operation to release supplied buffers.

### `opcode::RenameAt`
Represents a `renameat` operation.

### `opcode::Send`
Represents a `send` operation for sending data to a socket.

### `opcode::SendBundle`
Represents a `send_bundle` operation.

### `opcode::SendMsg`
Represents a `sendmsg` operation for sending messages.

### `opcode::SendMsgZc`
Represents a `sendmsg_zc` operation for zero-copy send.

### `opcode::SendZc`
Represents a `send_zc` operation for zero-copy send.

### `opcode::Shutdown`
Represents a `shutdown` operation for socket connections.

### `opcode::Socket`
Represents a `socket` operation for creating sockets.

### `opcode::Splice`
Represents a `splice` operation for transferring data between file descriptors.

### `opcode::Statx`
Represents a `statx` operation for retrieving file status.

### `opcode::SymlinkAt`
Represents a `symlinkat` operation.

### `opcode::SyncFileRange`
Represents a `sync_file_range` operation.

### `opcode::Tee`
Represents a `tee` operation.

### `opcode::Timeout`
Represents a `timeout` operation for setting timeouts.

### `opcode::TimeoutRemove`
Represents a `timeout_remove` operation to cancel a pending timeout.

### `opcode::TimeoutUpdate`
Represents a `timeout_update` operation to modify a pending timeout.

### `opcode::UnlinkAt`
Represents an `unlinkat` operation.

### `opcode::UringCmd16`
Represents a 16-bit `uring_cmd` operation.

### `opcode::UringCmd80`
Represents an 80-bit `uring_cmd` operation.

### `opcode::Write`
Represents a `write` operation for writing data to a file descriptor.

### `opcode::WriteFixed`
Represents a `write_fixed` operation with a pre-allocated buffer.

### `opcode::Writev`
Represents a `writev` operation for writing scattered data.

### `register::Probe`
Represents a `probe` operation to query supported io_uring features.

### `register::Restriction`
Represents restrictions on registered file descriptors.

### `squeue::Entry`
A struct representing a single entry in the submission queue.

### `squeue::Entry128`
A 128-bit representation of a submission queue entry.

### `squeue::Flags`
Flags associated with submission queue entries.

### `squeue::PushError`
Represents an error during submission queue push.

### `squeue::SubmissionQueue`
Represents the submission queue where operations are prepared.

### `types::AtFlags`
Flags for `openat` and similar operations.

### `types::BufRingEntry`
An entry in a buffer ring.

### `types::CancelBuilder`
Builder for constructing `AsyncCancel` requests.

### `types::DestinationSlot`
Represents a destination slot for data transfer.

### `types::EpollEvent`
An epoll event structure.

### `types::Fd`
Represents a file descriptor.

### `types::Fixed`
Information about fixed buffers or file descriptors.

### `types::FsyncFlags`
Flags for the `fsync` operation.

### `types::FutexWaitV`
Parameters for the `futex_waitv` operation.

### `types::Mode`
File mode for creation operations.

### `types::MsgHdr`
Message header for socket operations.

### `types::OFlags`
Open flags for file operations.

### `types::OpenHow`
Detailed open options for `openat2`.

### `types::RecvMsgOut`
Output structure for `recvmsg` operations.

### `types::RenameFlags`
Flags for the `renameat` operation.

### `types::ResolveFlags`
Flags for address resolution.

### `types::RwFlags`
Read/write flags.

### `types::SocketAddrOpaque`
An opaque socket address structure.

### `types::Statx`
Structure to hold file status information from `statx`.

### `types::StatxFlags`
Flags for the `statx` operation.

### `types::SubmitArgs`
Arguments for submitting operations.

### `types::TimeoutFlags`
Flags for timeout operations.

### `types::Timespec`
Time specification structure.

### `types::iovec`
An `iovec` structure for scatter/gather I/O.

```

--------------------------------

### rustix-uring Functions

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/all

Documentation for utility functions within rustix-uring, such as buffer selection and checking queue status.

```APIDOC
## Functions

### `cqueue::buffer_select`
Selects a buffer from the buffer ring.

### `cqueue::more`
Checks if there are more completion queue entries available.

### `cqueue::notif`
Notifies the system about completed operations.

### `cqueue::sock_nonempty`
Checks if a socket's receive buffer is non-empty.
```

--------------------------------

### rustix-uring Flags Initialization and Conversion

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/cqueue/struct

Provides methods for initializing a Flags value or converting from/to raw bit representations. This includes creating empty or all-set flags, and converting from `u32` with various truncation or retain options.

```rust
pub const fn empty() -> Self
pub const fn all() -> Self
pub const fn from_bits(bits: u32) -> Option<Self>
pub const fn from_bits_truncate(bits: u32) -> Self
pub const fn from_bits_retain(bits: u32) -> Self
pub fn from_name(name: &str) -> Option<Self>
```

--------------------------------

### Configuring Writev Operation in Rust

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/opcode/struct

Provides methods to configure the `Writev` operation. `ioprio` sets the I/O priority, `offset` specifies the file offset for the write, and `rw_flags` allows setting per-I/O flags relevant to write operations as described in `preadv2(2)`.

```rust
impl Writev {
    pub const fn ioprio(self, ioprio: u16) -> Self
    pub const fn offset(self, offset: u64) -> Self
    pub const fn rw_flags(self, rw_flags: RwFlags) -> Self
}
```

--------------------------------

### rustix-uring Constants

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/all

Documentation for constants defined in rustix-uring, such as `register::SKIP_FILE`.

```APIDOC
## Constants

### `register::SKIP_FILE`
A constant value used to indicate skipping file registration in certain operations.
```

--------------------------------

### Register Probe

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Fills a `Probe` object with information about the opcodes supported by io_uring on the running kernel.

```APIDOC
## POST /register/probe

### Description
Fill in the given `Probe` with information about the opcodes supported by io_uring on the running kernel.

### Method
POST

### Endpoint
/register/probe

### Parameters
#### Request Body
- **probe** (Probe) - Required - A mutable reference to a `Probe` object to be filled with supported opcode information.

### Request Example
```json
{
  "probe": {}
}
```

### Response
#### Success Response (200)
- **Result** (Result<()>) - Indicates success or failure of the operation.

#### Examples
```rust
let io_uring = rustix_uring::IoUring::new(1)?;
let mut probe = rustix_uring::Probe::new();
io_uring.submitter().register_probe(&mut probe)?;

if probe.is_supported(rustix_uring::opcode::Read::CODE) {
    println!("Reading is supported!");
}
```
```

--------------------------------

### Submitter API

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Methods for submitting and managing submission queue events with io_uring.

```APIDOC
## `enter_sigmask`

### Description
Initiate and/or complete asynchronous I/O. This is a low-level wrapper around `io_uring_enter`.

### Method
`unsafe fn enter_sigmask(&self, to_submit: u32, min_complete: u32, flag: IoringEnterFlags, arg: Option<&KernelSigSet>) -> Result<usize>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- **usize**: The number of events submitted or completed.

#### Response Example
```json
{
  "result": 10
}
```

## `enter_arg`

### Description
Initiate and/or complete asynchronous I/O. This is a low-level wrapper around `io_uring_enter`.

### Method
`unsafe fn enter_arg(&self, to_submit: u32, min_complete: u32, flag: IoringEnterFlags, arg: Option<&io_uring_getevents_arg>) -> Result<usize>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- **usize**: The number of events submitted or completed.

#### Response Example
```json
{
  "result": 10
}
```

## `submit`

### Description
Submit all queued submission queue events to the kernel.

### Method
`pub fn submit(&self) -> Result<usize>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- **usize**: The number of events submitted.

#### Response Example
```json
{
  "result": 5
}
```

## `submit_and_wait`

### Description
Submit all queued submission queue events to the kernel and wait for at least `want` completion events to complete.

### Method
`pub fn submit_and_wait(&self, want: usize) -> Result<usize>`

### Parameters
#### Path Parameters
None

#### Query Parameters
- **want** (usize) - Required - The minimum number of completion events to wait for.

#### Request Body
None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- **usize**: The number of completion events that occurred.

#### Response Example
```json
{
  "result": 7
}
```

## `submit_with_args`

### Description
Submit queued submission queue events with additional arguments.

### Method
`pub fn submit_with_args(&self, want: usize, args: &SubmitArgs<'_, '_>) -> Result<usize>`

### Parameters
#### Path Parameters
None

#### Query Parameters
- **want** (usize) - Required - The minimum number of completion events to wait for.
- **args** (SubmitArgs) - Required - Additional submission arguments.

#### Request Body
None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- **usize**: The number of events submitted or completed.

#### Response Example
```json
{
  "result": 8
}
```

## `squeue_wait`

### Description
Wait for the submission queue to have free entries.

### Method
`pub fn squeue_wait(&self) -> Result<usize>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- **usize**: The number of available free entries in the submission queue.

#### Response Example
```json
{
  "result": 3
}
```

## `register_buffers`

### Description
Register in-memory fixed buffers for I/O with the kernel. These buffers can be used with `ReadFixed` and `WriteFixed` operations.

### Method
`unsafe fn register_buffers(&self, bufs: &[iovec]) -> Result<()>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **bufs** (array of iovec) - Required - A slice of `iovec` structures representing the buffers to register.

### Request Example
```json
{
  "bufs": [
    {
      "iov_base": "0x...",
      "iov_len": 4096
    }
  ]
}
```

### Response
#### Success Response (200)
- **()**: Indicates successful registration.

#### Response Example
```json
{
  "success": true
}
```

## `register_buffers_update`

### Description
Update a range of fixed buffers starting at `offset`. This is required to use buffers registered using `register_buffers_sparse`.

### Method
`unsafe fn register_buffers_update(&self, offset: u32, bufs: &[iovec], tags: Option<&[u64]>) -> Result<()>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **offset** (u32) - Required - The starting offset for the buffer update.
- **bufs** (array of iovec) - Required - A slice of `iovec` structures representing the updated buffers.
- **tags** (array of u64, optional) - Optional - Resource tags for the updated buffers.

### Request Example
```json
{
  "offset": 0,
  "bufs": [
    {
      "iov_base": "0x...",
      "iov_len": 4096
    }
  ],
  "tags": [1001]
}
```

### Response
#### Success Response (200)
- **()**: Indicates successful update.

#### Response Example
```json
{
  "success": true
}
```

## `register_buffers2`

### Description
Variant of `register_buffers` with resource tagging. `tags` should be the same length as `bufs` and contain the tag value corresponding to the buffer at the same index.

### Method
`pub unsafe fn register_buffers2(&self, bufs: &[iovec], tags: &[u64]) -> Result<()>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **bufs** (array of iovec) - Required - A slice of `iovec` structures representing the buffers to register.
- **tags** (array of u64) - Required - Resource tags for the buffers.

### Request Example
```json
{
  "bufs": [
    {
      "iov_base": "0x...",
      "iov_len": 4096
    }
  ],
  "tags": [1001]
}
```

### Response
#### Success Response (200)
- **()**: Indicates successful registration.

#### Response Example
```json
{
  "success": true
}
```

## `register_buffers_sparse`

### Description
Registers an empty table of `nr` fixed buffers. These must be updated before use, using e.g. `register_buffers_update`.

### Method
`pub fn register_buffers_sparse(&self, nr: u32) -> Result<()>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **nr** (u32) - Required - The number of fixed buffers to reserve space for.

### Request Example
```json
{
  "nr": 10
}
```

### Response
#### Success Response (200)
- **()**: Indicates successful registration.

#### Response Example
```json
{
  "success": true
}
```

## `register_files_sparse`

### Description
Registers an empty file table of `nr_files` number of file descriptors. The sparse variant is available in kernels 5.19 and later.

### Method
`pub fn register_files_sparse(&self, nr: u32) -> Result<()>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **nr** (u32) - Required - The number of file descriptors to reserve space for.

### Request Example
```json
{
  "nr": 5
}
```

### Response
#### Success Response (200)
- **()**: Indicates successful registration.

#### Response Example
```json
{
  "success": true
}
```

## `register_files`

### Description
Register files for I/O. Each fd may be -1, in which case it is considered “sparse”, and can be filled in later with `register_files_update`. Note that this will wait for the ring to idle.

### Method
`pub fn register_files(&self, fds: &[RawFd]) -> Result<()>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **fds** (array of RawFd) - Required - A slice of raw file descriptors to register.

### Request Example
```json
{
  "fds": [10, 11, -1]
}
```

### Response
#### Success Response (200)
- **()**: Indicates successful registration.

#### Response Example
```json
{
  "success": true
}
```
```

--------------------------------

### rustix-uring Enums

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/all

Documentation for enumerations used in rustix-uring, such as `types::Advice`.

```APIDOC
## Enums

### `types::Advice`
Represents advice that can be given to the kernel regarding memory usage (e.g., for `madvise`).
```

--------------------------------

### rustix-uring Traits

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/all

Documentation for traits provided by rustix-uring, including marker traits for completion and submission queue entries.

```APIDOC
## Traits

### `cqueue::EntryMarker`
A marker trait indicating a type can be used as a completion queue entry.

### `squeue::EntryMarker`
A marker trait indicating a type can be used as a submission queue entry.
```

--------------------------------

### Register Enable Rings

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Enables the io_uring rings if they have been disabled using `setup_r_disabled`.

```APIDOC
## POST /register/enable_rings

### Description
Enable the rings of the io_uring instance if they have been disabled with `setup_r_disabled`.

### Method
POST

### Endpoint
/register/enable_rings

### Response
#### Success Response (200)
- **Result** (Result<()>) - Indicates success or failure of the operation.
```

--------------------------------

### Building Writev Operation Entry in Rust

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/opcode/struct

The `build` method on the `Writev` struct is used to construct the final `Entry` object. This `Entry` can then be submitted to the io_uring instance for execution.

```rust
impl Writev {
    pub fn build(self) -> Entry
}
```

--------------------------------

### Submit io_uring Events - Rust

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Provides methods to submit submission queue events to the kernel. Includes low-level wrappers for io_uring_enter and higher-level abstractions for submitting and waiting for completions.

```rust
pub unsafe fn enter_sigmask( &self, to_submit: u32, min_complete: u32, flag: IoringEnterFlags, arg: Option<&KernelSigSet> ) -> Result<usize>
pub unsafe fn enter_arg( &self, to_submit: u32, min_complete: u32, flag: IoringEnterFlags, arg: Option<&io_uring_getevents_arg> ) -> Result<usize>
pub fn submit(&self) -> Result<usize>
pub fn submit_and_wait(&self, want: usize) -> Result<usize>
pub fn submit_with_args( &self, want: usize, args: &SubmitArgs<'_, '_> ) -> Result<usize>
pub fn squeue_wait(&self) -> Result<usize>
```

--------------------------------

### Register Files - Rust

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Enables registration of file descriptors with the io_uring instance for I/O operations using the `Fixed` mechanism. Supports sparse registration and updates to avoid blocking.

```rust
pub fn register_files_sparse(&self, nr: u32) -> Result<()>
pub fn register_files(&self, fds: &[RawFd]) -> Result<()>
```

--------------------------------

### rustix-uring Type Aliases

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/all

Documentation for type aliases used in rustix-uring, simplifying common types like `Result` and socket address lengths.

```APIDOC
## Type Aliases

### `Result`
A type alias for `std::result::Result` commonly used for fallible operations.

### `types::SocketAddrLen`
A type alias for the length of a socket address structure.
```

--------------------------------

### Rust: EntryMarker Implementations

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/cqueue/trait

Shows how the EntryMarker trait is implemented for the Entry and Entry32 types. For Entry32, BUILD_FLAGS is explicitly set to sys::IoringSetupFlags::CQE32. For Entry, BUILD_FLAGS is an associated constant that needs to be defined by the implementor.

```rust
impl EntryMarker for Entry32 {
    const BUILD_FLAGS: IoringSetupFlags = sys::IoringSetupFlags::CQE32;
}
```

```rust
impl EntryMarker for Entry {
    const BUILD_FLAGS: IoringSetupFlags;
}
```

--------------------------------

### Equality and inequality comparison for Flags

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/cqueue/struct

Implements `PartialEq` for the `Flags` type, enabling equality (`==`) and inequality (`!=`) comparisons between `Flags` instances. The `ne` method provides the default inequality check.

```Rust
impl PartialEq for Flags {
  fn eq(&self, other: &Flags) -> bool;
  fn ne(&self, other: &Rhs) -> bool;
}
```

--------------------------------

### Writev Struct Definition and Constructor in Rust

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/opcode/struct

Defines the `Writev` struct used for vectored write operations. It includes a constant `CODE` for the operation's opcode and a `new` function to construct a `Writev` instance with a file descriptor, an array of `iovec` structures, and the number of vectors.

```rust
pub struct Writev { /* private fields */ }

impl Writev {
    pub const CODE: IoringOp
    pub fn new(fd: impl UseFixed, iovec: *const iovec, len: u32) -> Self
}
```

--------------------------------

### Rust: EntryMarker Trait Definition

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/cqueue/trait

Defines the EntryMarker trait, which is implemented by types representing completion queue entries. It requires the type to be Clone, Debug, convertible into an Entry, and to implement the Sealed trait. It also mandates a BUILD_FLAGS associated constant of type IoringSetupFlags.

```rust
pub trait EntryMarker:
    Clone
    + Debug
    + Into<Entry>
    + Sealed {
    const BUILD_FLAGS: IoringSetupFlags;
}
```

--------------------------------

### Register Files Update

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Replaces existing files in the registered file set with new ones. This can be used to add, remove, or update file entries.

```APIDOC
## POST /register/files/update

### Description
Replaces existing files in the registered file set with new ones, either turning a sparse entry into a real one, removing an existing entry, or replacing an existing entry with a new existing entry. The `offset` parameter specifies the offset into the list of registered files at which to start updating files.

### Method
POST

### Endpoint
/register/files/update

### Parameters
#### Query Parameters
- **offset** (u32) - Required - The offset into the list of registered files to start updating.
- **fds** ([RawFd]) - Required - A slice of raw file descriptors representing the new files.

### Request Example
```json
{
  "offset": 0,
  "fds": [3, 4, -1, 6]
}
```

### Response
#### Success Response (200)
- **Result** (Result<()>) - Indicates success or failure of the operation.
```

--------------------------------

### Rust: Probe Struct for io_uring Feature Support

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/register/index

The Probe struct provides information about the io_uring features supported by the kernel. This is crucial for determining compatibility and available functionalities.

```rust
struct Probe

/*
 * Information about what `io_uring` features the kernel supports.
 */
```

--------------------------------

### PushError Documentation

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/squeue/struct

Details the PushError struct, an error type indicating that the submission queue is full. Includes information on its `Clone`, `Debug`, `Display`, `Error`, `PartialEq`, `Eq`, and `StructuralPartialEq` trait implementations.

```APIDOC
## Struct PushError

### Description
An error pushing to the submission queue due to it being full.

### Method
N/A (Struct Definition)

### Endpoint
N/A

### Parameters
N/A

### Request Body
N/A

### Response
N/A

## Trait Implementations

### `impl Clone for PushError`

#### `fn clone(&self) -> PushError`
Returns a duplicate of the value.

#### `fn clone_from(&mut self, source: &Self)`
Performs copy-assignment from `source`.

### `impl Debug for PushError`

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result`
Formats the value using the given formatter.

### `impl Display for PushError`

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result`
Formats the value using the given formatter.

### `impl Error for PushError`

#### `fn source(&self) -> Option<&(dyn Error + 'static)>`
Returns the lower-level source of this error, if any.

#### `fn description(&self) -> &str`
*Deprecated*: use the Display impl or to_string().

#### `fn cause(&self) -> Option<&dyn Error>`
*Deprecated*: replaced by Error::source, which can support downcasting.

#### `fn provide<'a>(&'a self, request: &mut Request<'a>)`
*Nightly-only experimental API.* Provides type-based access to context intended for error reports.

### `impl PartialEq for PushError`

#### `fn eq(&self, other: &PushError) -> bool`
Tests for `self` and `other` values to be equal.

#### `fn ne(&self, other: &Rhs) -> bool`
Tests for `!=`.

### `impl Eq for PushError`

### `impl StructuralPartialEq for PushError`

## Auto Trait Implementations

### `impl Freeze for PushError`

### `impl RefUnwindSafe for PushError`

### `impl Send for PushError`

### `impl Sync for PushError`

### `impl Unpin for PushError`

### `impl UnwindSafe for PushError`

## Blanket Implementations

### `impl<T> Any for T`

#### `fn type_id(&self) -> TypeId`
Gets the `TypeId` of `self`.

### `impl<T> Borrow<T> for T`

#### `fn borrow(&self) -> &T`
Immutably borrows from an owned value.

### `impl<T> BorrowMut<T> for T`

#### `fn borrow_mut(&mut self) -> &mut T`
Mutably borrows from an owned value.

### `impl<T> CloneToUninit for T`

#### `unsafe fn clone_to_uninit(&self, dest: *mut u8)`
*Nightly-only experimental API.* Performs copy-assignment from `self` to `dest`.

### `impl<T> From<T> for T`

#### `fn from(t: T) -> T`
Returns the argument unchanged.

### `impl<T, U> Into<U> for T`

#### `fn into(self) -> U`
Calls `U::from(self)`.

### `impl<T, U> TryFrom<U> for T`

#### `type Error = Infallible`

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`
Performs the conversion.

### `impl<T, U> TryInto<U> for T`

#### `type Error = <U as TryFrom<T>>::Error`

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`
Performs the conversion.
```

--------------------------------

### Rust: Enable io_uring Rings

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Enables the io_uring instance's rings if they have been previously disabled using `setup_r_disabled`. This function is used to re-activate the io_uring interface after it has been put into a disabled state.

```rust
pub fn register_enable_rings(&self) -> Result<()>
```

--------------------------------

### Debug Implementation for Writev in Rust

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/opcode/struct

This snippet shows the implementation of the `Debug` trait for the `Writev` struct, allowing instances of `Writev` to be formatted for debugging purposes using a given formatter.

```rust
impl Debug for Writev {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result
}
```

--------------------------------

### Register IOWQ Affinity

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Specifies the CPUs on which io_uring's asynchronous workers can run.

```APIDOC
## POST /register/iowq_aff

### Description
Tell io_uring on what CPUs the async workers can run. By default, async workers created by io_uring will inherit the CPU mask of its parent. This is usually all the CPUs in the system, unless the parent is being run with a limited set.

### Method
POST

### Endpoint
/register/iowq_aff

### Parameters
#### Request Body
- **cpu_set** (CpuSet) - Required - A `CpuSet` specifying the allowed CPUs for async workers.

### Request Example
```json
{
  "cpu_set": {
    "mask": ["0x0000000000000001", "0x0000000000000000"]
  }
}
```

### Response
#### Success Response (200)
- **Result** (Result<()>) - Indicates success or failure of the operation.
```

--------------------------------

### Register Event File Descriptor (Async)

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Registers an eventfd asynchronously, posting notifications only for events that complete in an async manner.

```APIDOC
## POST /register/eventfd/async

### Description
Works like `register_eventfd`, except notifications are only posted for events that complete in an async manner, so requests that complete immediately will not cause a notification.

### Method
POST

### Endpoint
/register/eventfd/async

### Parameters
#### Query Parameters
- **eventfd** (RawFd) - Required - The event file descriptor to register.

### Request Example
```json
{
  "eventfd": 5
}
```

### Response
#### Success Response (200)
- **Result** (Result<()>) - Indicates success or failure of the operation.
```

--------------------------------

### Register Personality

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Registers the credentials of the running application with io_uring and obtains an ID associated with these credentials.

```APIDOC
## POST /register/personality

### Description
Register credentials of the running application with io_uring, and get an id associated with these credentials. This ID can then be passed into submission queue entries to issue the request with this process’ credentials.
By default, if `Parameters::is_feature_cur_personality` is set then requests will use the credentials of the task that called [`Submitter::enter`], otherwise they will use the credentials of the task that originally registered the io_uring.

### Method
POST

### Endpoint
/register/personality

### Response
#### Success Response (200)
- **personality_id** (u16) - The ID associated with the registered credentials.
```

--------------------------------

### EntryMarker Trait Definition (Rust)

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/squeue/trait

Defines the EntryMarker trait, representing a submission queue entry (SQE). It requires implementations to be Clone, Debug, From<Entry>, and Sealed, and to provide a BUILD_FLAGS associated constant.

```rust
pub trait EntryMarker:
    Clone
    + Debug
    + From<Entry>
    + Sealed {
    const BUILD_FLAGS: IoringSetupFlags;
}
```

--------------------------------

### Register Event File Descriptor

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Registers an eventfd with the io_uring instance for receiving event notifications.

```APIDOC
## POST /register/eventfd

### Description
Registers an eventfd created by `eventfd` with the io_uring instance.

### Method
POST

### Endpoint
/register/eventfd

### Parameters
#### Query Parameters
- **eventfd** (RawFd) - Required - The event file descriptor to register.

### Request Example
```json
{
  "eventfd": 5
}
```

### Response
#### Success Response (200)
- **Result** (Result<()>) - Indicates success or failure of the operation.
```

--------------------------------

### EntryMarker Implementations (Rust)

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/squeue/trait

Shows implementations of the EntryMarker trait for Entry128 and Entry. Entry128 specifies SQE128 flags, while Entry uses a default BUILD_FLAGS constant.

```rust
impl EntryMarker for Entry128 {
    const BUILD_FLAGS: IoringSetupFlags = sys::IoringSetupFlags::SQE128;
}
```

```rust
impl EntryMarker for Entry {
    const BUILD_FLAGS: IoringSetupFlags
}
```

--------------------------------

### Re-export CompletionQueue from cqueue

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/index

This snippet shows the re-export of the CompletionQueue type from the cqueue module. CompletionQueue is essential for retrieving the results of asynchronous I/O operations.

```rust
pub use cqueue::CompletionQueue;

```

--------------------------------

### Re-export Probe from register

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/index

This snippet demonstrates the re-export of the Probe type from the register module. The Probe type is used for querying the capabilities and features supported by the io_uring instance.

```rust
pub use register::Probe;

```

--------------------------------

### Unregister Files

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/struct

Unregisters all previously registered files. This is automatically handled when the `IoUring` is dropped.

```APIDOC
## DELETE /unregister/files

### Description
Unregister all previously registered files. You do not need to explicitly call this before dropping the `IoUring`, as it will be cleaned up by the kernel automatically.

### Method
DELETE

### Endpoint
/unregister/files

### Response
#### Success Response (200)
- **Result** (Result<()>) - Indicates success or failure of the operation.
```

--------------------------------

### Cloning and Copying Flags

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/cqueue/struct

Provides implementations for `Clone` and `clone_from` for the `Flags` type. `clone` creates a duplicate of the `Flags` value, while `clone_from` performs copy-assignment from another `Flags` value.

```rust
impl Clone for Flags {
    fn clone(&self) -> Flags {
        // Implementation details for cloning
    }

    fn clone_from(&mut self, source: &Self) {
        // Implementation details for clone_from
    }
}
```

--------------------------------

### Rust: Blanket Implementation of TryInto for T

Source: https://docs.rs/rustix-uring/0.6.0/rustix_uring/register/struct

Implements `TryInto<U>` for `T` where `U` implements `TryFrom<T>`. This allows attempting conversions that might fail, returning a `Result`.

```rust
type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```
Tokens:
Raw