NAME

       io_uring_sqe_set_flags - set flags for submission queue entry

SYNOPSIS

       #include <liburing.h>

       void io_uring_sqe_set_flags(struct io_uring_sqe *sqe,
                                   unsigned flags);

DESCRIPTION

       The  io_uring_sqe_set_flags(3)  function allows the caller to change the behavior of the submission queue
       entry by specifying flags. It enables the flags belonging to the sqe submission queue entry param.

       flags is a bit mask of 0 or more of the following values ORed together:

       IOSQE_FIXED_FILE
              The file descriptor in the SQE refers to the index of a previously registered file or direct  file
              descriptor, not a normal file descriptor.

       IOSQE_ASYNC
              Normal operation for io_uring is to try and issue an sqe as non-blocking first, and if that fails,
              execute it in an async manner. To support more efficient overlapped operation of requests that the
              application  knows/assumes will always (or most of the time) block, the application can ask for an
              sqe to be issued async from the start. Note that this  flag  immediately  causes  the  SQE  to  be
              offloaded  to  an  async  helper  thread  with  no initial non-blocking attempt.  This may be less
              efficient and should not be used liberally or without understanding the performance and efficiency
              tradeoffs.

       IOSQE_IO_LINK
              When this flag is specified, the SQE forms a link with the next SQE in the submission  ring.  That
              next SQE will not be started before the previous request completes. This, in effect, forms a chain
              of  SQEs,  which  can  be arbitrarily long. The tail of the chain is denoted by the first SQE that
              does not have this flag set. Chains are not supported across submission boundaries.  Even  if  the
              last  SQE  in a submission has this flag set, it will still terminate the current chain. This flag
              has no effect on previous SQE submissions, nor does it impact SQEs that are outside of  the  chain
              tail. This means that multiple chains can be executing in parallel, or chains and individual SQEs.
              Only  members  inside  the  chain are serialized. A chain of SQEs will be broken if any request in
              that chain ends in error.

       IOSQE_IO_HARDLINK
              Like IOSQE_IO_LINK , except the links aren't severed if an error or unexpected result occurs.

       IOSQE_IO_DRAIN
              When this flag is specified, the SQE will not be started before  previously  submitted  SQEs  have
              completed, and new SQEs will not be started before this one completes.

       IOSQE_CQE_SKIP_SUCCESS
              Request  that  no  CQE  be  generated for this request, if it completes successfully.  This can be
              useful in cases where the application doesn't need to know when a specific request  completed,  if
              it completed successfully.

       IOSQE_BUFFER_SELECT
              If set, and if the request types supports it, select an IO buffer from the indicated buffer group.
              This  can  be  used  with  requests  that read or receive data from a file or socket, where buffer
              selection is deferred until the kernel is ready to transfer  data,  instead  of  when  the  IO  is
              originally  submitted.  The  application  must also set the buf_group field in the SQE, indicating
              which previously registered buffer group to select a buffer from.

RETURN VALUE

       None

SEE ALSO

       io_uring_submit(3), io_uring_register(3) io_uring_register_buffers(3) io_uring_register_buf_ring(3)

liburing-2.1                                    January 25, 2022                       io_uring_sqe_set_flags(3)