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 sporadically.

       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)