# io_uring_prep_timeout

## NAME



           io_uring_prep_timeout - prepare a timeout request
    


## SYNOPSIS



           **#include <liburing.h>**
    
           **void io_uring_prep_timeout(struct io_uring_sqe ***_sqe_**,**
                                      **struct __kernel_timespec ***_ts_**,**
                                      **unsigned** _count_**,**
                                      **unsigned** _flags_**);**
    


## DESCRIPTION



           The io_uring_prep_timeout(3) function prepares a timeout request.
           The submission queue entry _sqe_ is setup to arm a timeout specified
           by _ts_ and with a timeout count of _count_ completion entries. The
           _flags_ argument holds modifier flags for the request.
    
           This request type can be used as a timeout waking anyone sleeping
           for events on the CQ ring. The _flags_ argument may contain:
    
           **IORING_TIMEOUT_ABS**
                  The value specified in _ts_ is an absolute value rather than
                  a relative one.
    
           **IORING_TIMEOUT_BOOTTIME**
                  The boottime clock source should be used.
    
           **IORING_TIMEOUT_REALTIME**
                  The realtime clock source should be used.
    
           **IORING_TIMEOUT_ETIME_SUCCESS**
                  Consider an expired timeout a success in terms of the
                  posted completion. This means it will not sever dependent
                  links, as a failed request normally would. The posted CQE
                  result code will still contain **-ETIME** in the _res_ value.
    
           **IORING_TIMEOUT_MULTISHOT**
                  The request will return multiple timeout completions. The
                  completion flag IORING_CQE_F_MORE is set if more timeouts
                  are expected. The value specified in _count_ is the number of
                  repeats. A value of 0 means the timeout is indefinite and
                  can only be stopped by a removal request. Available since
                  the 6.4 kernel.
    
           If no alternate clock source is given in the above flags, then
           **CLOCK_MONOTONIC** is used.
    
           The timeout completion event will trigger if either the specified
           timeout has occurred, or the specified number of events to wait
           for have been posted to the CQ ring.
    


## RETURN VALUE



           None
    


## ERRORS



           These are the errors that are reported in the CQE _res_ field. On
           success, **0** is returned.
    
           **-ETIME** The specified timeout occurred and triggered the completion
                  event.
    
           **-EINVAL**
                  One of the fields set in the SQE was invalid. For example,
                  two clocksources were given, or the specified timeout
                  seconds or nanoseconds were < 0.
    
           **-EFAULT**
                  io_uring was unable to access the data specified by _ts_.
    
           **-ECANCELED**
                  The timeout was canceled by a removal request.
    


## NOTES



           As with any request that passes in data in a struct, that data
           must remain valid until the request has been successfully
           submitted. It need not remain valid until completion. Once a
           request has been submitted, the in-kernel state is stable. Very
           early kernels (5.4 and earlier) required state to be stable until
           the completion occurred. Applications can test for this behavior
           by inspecting the **IORING_FEAT_SUBMIT_STABLE** flag passed back from
           io_uring_queue_init_params(3).
    


* * *