io_uring/io_uring.h

   1 #ifndef IOU_CORE_H
   2 #define IOU_CORE_H
   3
   4 #include <linux/errno.h>
   5 #include <linux/lockdep.h>
   6 #include <linux/io_uring_types.h>
   7 #include "io-wq.h"
   8 #include "slist.h"
   9 #include "filetable.h"
  10
  11 #ifndef CREATE_TRACE_POINTS
  12 #include <trace/events/io_uring.h>
  13 #endif
  14
  15 enum {
  16         IOU_OK                  = 0,
  17         IOU_ISSUE_SKIP_COMPLETE = -EIOCBQUEUED,
  18
  19         /*
  20          * Intended only when both REQ_F_POLLED and REQ_F_APOLL_MULTISHOT
  21          * are set to indicate to the poll runner that multishot should be
  22          * removed and the result is set on req->cqe.res.
  23          */
  24         IOU_STOP_MULTISHOT      = -ECANCELED,
  25 };
  26
  27 struct io_uring_cqe *__io_get_cqe(struct io_ring_ctx *ctx);
  28 bool io_req_cqe_overflow(struct io_kiocb *req);
  29 int io_run_task_work_sig(void);
  30 void io_req_complete_failed(struct io_kiocb *req, s32 res);
  31 void __io_req_complete(struct io_kiocb *req, unsigned issue_flags);
  32 void io_req_complete_post(struct io_kiocb *req);
  33 void __io_req_complete_post(struct io_kiocb *req);
  34 bool io_post_aux_cqe(struct io_ring_ctx *ctx, u64 user_data, s32 res, u32 cflags,
  35                      bool allow_overflow);
  36 bool io_fill_cqe_aux(struct io_ring_ctx *ctx, u64 user_data, s32 res, u32 cflags,
  37                      bool allow_overflow);
  38 void __io_commit_cqring_flush(struct io_ring_ctx *ctx);
  39
  40 struct page **io_pin_pages(unsigned long ubuf, unsigned long len, int *npages);
  41
  42 struct file *io_file_get_normal(struct io_kiocb *req, int fd);
  43 struct file *io_file_get_fixed(struct io_kiocb *req, int fd,
  44                                unsigned issue_flags);
  45
  46 static inline bool io_req_ffs_set(struct io_kiocb *req)
  47 {
  48         return req->flags & REQ_F_FIXED_FILE;
  49 }
  50
  51 bool io_is_uring_fops(struct file *file);
  52 bool io_alloc_async_data(struct io_kiocb *req);
  53 void io_req_task_work_add(struct io_kiocb *req);
  54 void io_req_tw_post_queue(struct io_kiocb *req, s32 res, u32 cflags);
  55 void io_req_task_queue(struct io_kiocb *req);
  56 void io_queue_iowq(struct io_kiocb *req, bool *dont_use);
  57 void io_req_task_complete(struct io_kiocb *req, bool *locked);
  58 void io_req_task_queue_fail(struct io_kiocb *req, int ret);
  59 void io_req_task_submit(struct io_kiocb *req, bool *locked);
  60 void tctx_task_work(struct callback_head *cb);
  61 __cold void io_uring_cancel_generic(bool cancel_all, struct io_sq_data *sqd);
  62 int io_uring_alloc_task_context(struct task_struct *task,
  63                                 struct io_ring_ctx *ctx);
  64
  65 int io_poll_issue(struct io_kiocb *req, bool *locked);
  66 int io_submit_sqes(struct io_ring_ctx *ctx, unsigned int nr);
  67 int io_do_iopoll(struct io_ring_ctx *ctx, bool force_nonspin);
  68 void io_free_batch_list(struct io_ring_ctx *ctx, struct io_wq_work_node *node);
  69 int io_req_prep_async(struct io_kiocb *req);
  70
  71 struct io_wq_work *io_wq_free_work(struct io_wq_work *work);
  72 void io_wq_submit_work(struct io_wq_work *work);
  73
  74 void io_free_req(struct io_kiocb *req);
  75 void io_queue_next(struct io_kiocb *req);
  76 void __io_put_task(struct task_struct *task, int nr);
  77 void io_task_refs_refill(struct io_uring_task *tctx);
  78 bool __io_alloc_req_refill(struct io_ring_ctx *ctx);
  79
  80 bool io_match_task_safe(struct io_kiocb *head, struct task_struct *task,
  81                         bool cancel_all);
  82
  83 #define io_for_each_link(pos, head) \
  84         for (pos = (head); pos; pos = pos->link)
  85
  86 static inline void io_cq_lock(struct io_ring_ctx *ctx)
  87         __acquires(ctx->completion_lock)
  88 {
  89         spin_lock(&ctx->completion_lock);
  90 }
  91
  92 void io_cq_unlock_post(struct io_ring_ctx *ctx);
  93
  94 static inline struct io_uring_cqe *io_get_cqe(struct io_ring_ctx *ctx)
  95 {
  96         if (likely(ctx->cqe_cached < ctx->cqe_sentinel)) {
  97                 struct io_uring_cqe *cqe = ctx->cqe_cached;
  98
  99                 ctx->cached_cq_tail++;
 100                 ctx->cqe_cached++;
 101                 if (ctx->flags & IORING_SETUP_CQE32)
 102                         ctx->cqe_cached++;
 103                 return cqe;
 104         }
 105
 106         return __io_get_cqe(ctx);
 107 }
 108
 109 static inline bool __io_fill_cqe_req(struct io_ring_ctx *ctx,
 110                                      struct io_kiocb *req)
 111 {
 112         struct io_uring_cqe *cqe;
 113
 114         /*
 115          * If we can't get a cq entry, userspace overflowed the
 116          * submission (by quite a lot). Increment the overflow count in
 117          * the ring.
 118          */
 119         cqe = io_get_cqe(ctx);
 120         if (unlikely(!cqe))
 121                 return io_req_cqe_overflow(req);
 122
 123         trace_io_uring_complete(req->ctx, req, req->cqe.user_data,
 124                                 req->cqe.res, req->cqe.flags,
 125                                 (req->flags & REQ_F_CQE32_INIT) ? req->extra1 : 0,
 126                                 (req->flags & REQ_F_CQE32_INIT) ? req->extra2 : 0);
 127
 128         memcpy(cqe, &req->cqe, sizeof(*cqe));
 129
 130         if (ctx->flags & IORING_SETUP_CQE32) {
 131                 u64 extra1 = 0, extra2 = 0;
 132
 133                 if (req->flags & REQ_F_CQE32_INIT) {
 134                         extra1 = req->extra1;
 135                         extra2 = req->extra2;
 136                 }
 137
 138                 WRITE_ONCE(cqe->big_cqe[0], extra1);
 139                 WRITE_ONCE(cqe->big_cqe[1], extra2);
 140         }
 141         return true;
 142 }
 143
 144 static inline void req_set_fail(struct io_kiocb *req)
 145 {
 146         req->flags |= REQ_F_FAIL;
 147         if (req->flags & REQ_F_CQE_SKIP) {
 148                 req->flags &= ~REQ_F_CQE_SKIP;
 149                 req->flags |= REQ_F_SKIP_LINK_CQES;
 150         }
 151 }
 152
 153 static inline void io_req_set_res(struct io_kiocb *req, s32 res, u32 cflags)
 154 {
 155         req->cqe.res = res;
 156         req->cqe.flags = cflags;
 157 }
 158
 159 static inline bool req_has_async_data(struct io_kiocb *req)
 160 {
 161         return req->flags & REQ_F_ASYNC_DATA;
 162 }
 163
 164 static inline void io_put_file(struct file *file)
 165 {
 166         if (file)
 167                 fput(file);
 168 }
 169
 170 static inline void io_ring_submit_unlock(struct io_ring_ctx *ctx,
 171                                          unsigned issue_flags)
 172 {
 173         lockdep_assert_held(&ctx->uring_lock);
 174         if (issue_flags & IO_URING_F_UNLOCKED)
 175                 mutex_unlock(&ctx->uring_lock);
 176 }
 177
 178 static inline void io_ring_submit_lock(struct io_ring_ctx *ctx,
 179                                        unsigned issue_flags)
 180 {
 181         /*
 182          * "Normal" inline submissions always hold the uring_lock, since we
 183          * grab it from the system call. Same is true for the SQPOLL offload.
 184          * The only exception is when we've detached the request and issue it
 185          * from an async worker thread, grab the lock for that case.
 186          */
 187         if (issue_flags & IO_URING_F_UNLOCKED)
 188                 mutex_lock(&ctx->uring_lock);
 189         lockdep_assert_held(&ctx->uring_lock);
 190 }
 191
 192 static inline void io_commit_cqring(struct io_ring_ctx *ctx)
 193 {
 194         /* order cqe stores with ring update */
 195         smp_store_release(&ctx->rings->cq.tail, ctx->cached_cq_tail);
 196 }
 197
 198 static inline void io_cqring_wake(struct io_ring_ctx *ctx)
 199 {
 200         /*
 201          * wake_up_all() may seem excessive, but io_wake_function() and
 202          * io_should_wake() handle the termination of the loop and only
 203          * wake as many waiters as we need to.
 204          */
 205         if (wq_has_sleeper(&ctx->cq_wait))
 206                 wake_up_all(&ctx->cq_wait);
 207 }
 208
 209 static inline bool io_sqring_full(struct io_ring_ctx *ctx)
 210 {
 211         struct io_rings *r = ctx->rings;
 212
 213         return READ_ONCE(r->sq.tail) - ctx->cached_sq_head == ctx->sq_entries;
 214 }
 215
 216 static inline unsigned int io_sqring_entries(struct io_ring_ctx *ctx)
 217 {
 218         struct io_rings *rings = ctx->rings;
 219
 220         /* make sure SQ entry isn't read before tail */
 221         return smp_load_acquire(&rings->sq.tail) - ctx->cached_sq_head;
 222 }
 223
 224 static inline bool io_run_task_work(void)
 225 {
 226         if (test_thread_flag(TIF_NOTIFY_SIGNAL)) {
 227                 __set_current_state(TASK_RUNNING);
 228                 clear_notify_signal();
 229                 if (task_work_pending(current))
 230                         task_work_run();
 231                 return true;
 232         }
 233
 234         return false;
 235 }
 236
 237 static inline void io_tw_lock(struct io_ring_ctx *ctx, bool *locked)
 238 {
 239         if (!*locked) {
 240                 mutex_lock(&ctx->uring_lock);
 241                 *locked = true;
 242         }
 243 }
 244
 245 /*
 246  * Don't complete immediately but use deferred completion infrastructure.
 247  * Protected by ->uring_lock and can only be used either with
 248  * IO_URING_F_COMPLETE_DEFER or inside a tw handler holding the mutex.
 249  */
 250 static inline void io_req_complete_defer(struct io_kiocb *req)
 251         __must_hold(&req->ctx->uring_lock)
 252 {
 253         struct io_submit_state *state = &req->ctx->submit_state;
 254
 255         lockdep_assert_held(&req->ctx->uring_lock);
 256
 257         wq_list_add_tail(&req->comp_list, &state->compl_reqs);
 258 }
 259
 260 static inline void io_commit_cqring_flush(struct io_ring_ctx *ctx)
 261 {
 262         if (unlikely(ctx->off_timeout_used || ctx->drain_active || ctx->has_evfd))
 263                 __io_commit_cqring_flush(ctx);
 264 }
 265
 266 /* must to be called somewhat shortly after putting a request */
 267 static inline void io_put_task(struct task_struct *task, int nr)
 268 {
 269         if (likely(task == current))
 270                 task->io_uring->cached_refs += nr;
 271         else
 272                 __io_put_task(task, nr);
 273 }
 274
 275 static inline void io_get_task_refs(int nr)
 276 {
 277         struct io_uring_task *tctx = current->io_uring;
 278
 279         tctx->cached_refs -= nr;
 280         if (unlikely(tctx->cached_refs < 0))
 281                 io_task_refs_refill(tctx);
 282 }
 283
 284 static inline bool io_req_cache_empty(struct io_ring_ctx *ctx)
 285 {
 286         return !ctx->submit_state.free_list.next;
 287 }
 288
 289 static inline bool io_alloc_req_refill(struct io_ring_ctx *ctx)
 290 {
 291         if (unlikely(io_req_cache_empty(ctx)))
 292                 return __io_alloc_req_refill(ctx);
 293         return true;
 294 }
 295
 296 static inline struct io_kiocb *io_alloc_req(struct io_ring_ctx *ctx)
 297 {
 298         struct io_wq_work_node *node;
 299
 300         node = wq_stack_extract(&ctx->submit_state.free_list);
 301         return container_of(node, struct io_kiocb, comp_list);
 302 }
 303
 304 #endif