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 <uapi/linux/eventpoll.h>
   8 #include "io-wq.h"
   9 #include "slist.h"
  10 #include "filetable.h"
  11
  12 #ifndef CREATE_TRACE_POINTS
  13 #include <trace/events/io_uring.h>
  14 #endif
  15
  16 enum {
  17         IOU_OK                  = 0,
  18         IOU_ISSUE_SKIP_COMPLETE = -EIOCBQUEUED,
  19
  20         /*
  21          * Intended only when both IO_URING_F_MULTISHOT is passed
  22          * to indicate to the poll runner that multishot should be
  23          * removed and the result is set on req->cqe.res.
  24          */
  25         IOU_STOP_MULTISHOT      = -ECANCELED,
  26 };
  27
  28 struct io_uring_cqe *__io_get_cqe(struct io_ring_ctx *ctx, bool overflow);
  29 bool io_req_cqe_overflow(struct io_kiocb *req);
  30 int io_run_task_work_sig(struct io_ring_ctx *ctx);
  31 void io_req_defer_failed(struct io_kiocb *req, s32 res);
  32 void io_req_complete_post(struct io_kiocb *req, unsigned issue_flags);
  33 bool io_post_aux_cqe(struct io_ring_ctx *ctx, u64 user_data, s32 res, u32 cflags);
  34 bool io_aux_cqe(struct io_ring_ctx *ctx, bool defer, u64 user_data, s32 res, u32 cflags,
  35                 bool allow_overflow);
  36 void __io_commit_cqring_flush(struct io_ring_ctx *ctx);
  37
  38 struct page **io_pin_pages(unsigned long ubuf, unsigned long len, int *npages);
  39
  40 struct file *io_file_get_normal(struct io_kiocb *req, int fd);
  41 struct file *io_file_get_fixed(struct io_kiocb *req, int fd,
  42                                unsigned issue_flags);
  43
  44 static inline bool io_req_ffs_set(struct io_kiocb *req)
  45 {
  46         return req->flags & REQ_F_FIXED_FILE;
  47 }
  48
  49 void __io_req_task_work_add(struct io_kiocb *req, bool allow_local);
  50 bool io_is_uring_fops(struct file *file);
  51 bool io_alloc_async_data(struct io_kiocb *req);
  52 void io_req_task_queue(struct io_kiocb *req);
  53 void io_queue_iowq(struct io_kiocb *req, bool *dont_use);
  54 void io_req_task_complete(struct io_kiocb *req, bool *locked);
  55 void io_req_task_queue_fail(struct io_kiocb *req, int ret);
  56 void io_req_task_submit(struct io_kiocb *req, bool *locked);
  57 void tctx_task_work(struct callback_head *cb);
  58 __cold void io_uring_cancel_generic(bool cancel_all, struct io_sq_data *sqd);
  59 int io_uring_alloc_task_context(struct task_struct *task,
  60                                 struct io_ring_ctx *ctx);
  61
  62 int io_poll_issue(struct io_kiocb *req, bool *locked);
  63 int io_submit_sqes(struct io_ring_ctx *ctx, unsigned int nr);
  64 int io_do_iopoll(struct io_ring_ctx *ctx, bool force_nonspin);
  65 void io_free_batch_list(struct io_ring_ctx *ctx, struct io_wq_work_node *node);
  66 int io_req_prep_async(struct io_kiocb *req);
  67
  68 struct io_wq_work *io_wq_free_work(struct io_wq_work *work);
  69 void io_wq_submit_work(struct io_wq_work *work);
  70
  71 void io_free_req(struct io_kiocb *req);
  72 void io_queue_next(struct io_kiocb *req);
  73 void __io_put_task(struct task_struct *task, int nr);
  74 void io_task_refs_refill(struct io_uring_task *tctx);
  75 bool __io_alloc_req_refill(struct io_ring_ctx *ctx);
  76
  77 bool io_match_task_safe(struct io_kiocb *head, struct task_struct *task,
  78                         bool cancel_all);
  79
  80 #define io_lockdep_assert_cq_locked(ctx)                                \
  81         do {                                                            \
  82                 if (ctx->flags & IORING_SETUP_IOPOLL) {                 \
  83                         lockdep_assert_held(&ctx->uring_lock);          \
  84                 } else if (!ctx->task_complete) {                       \
  85                         lockdep_assert_held(&ctx->completion_lock);     \
  86                 } else if (ctx->submitter_task->flags & PF_EXITING) {   \
  87                         lockdep_assert(current_work());                 \
  88                 } else {                                                \
  89                         lockdep_assert(current == ctx->submitter_task); \
  90                 }                                                       \
  91         } while (0)
  92
  93 static inline void io_req_task_work_add(struct io_kiocb *req)
  94 {
  95         __io_req_task_work_add(req, true);
  96 }
  97
  98 #define io_for_each_link(pos, head) \
  99         for (pos = (head); pos; pos = pos->link)
 100
 101 void io_cq_unlock_post(struct io_ring_ctx *ctx);
 102
 103 static inline struct io_uring_cqe *io_get_cqe_overflow(struct io_ring_ctx *ctx,
 104                                                        bool overflow)
 105 {
 106         io_lockdep_assert_cq_locked(ctx);
 107
 108         if (likely(ctx->cqe_cached < ctx->cqe_sentinel)) {
 109                 struct io_uring_cqe *cqe = ctx->cqe_cached;
 110
 111                 ctx->cached_cq_tail++;
 112                 ctx->cqe_cached++;
 113                 if (ctx->flags & IORING_SETUP_CQE32)
 114                         ctx->cqe_cached++;
 115                 return cqe;
 116         }
 117
 118         return __io_get_cqe(ctx, overflow);
 119 }
 120
 121 static inline struct io_uring_cqe *io_get_cqe(struct io_ring_ctx *ctx)
 122 {
 123         return io_get_cqe_overflow(ctx, false);
 124 }
 125
 126 static inline bool __io_fill_cqe_req(struct io_ring_ctx *ctx,
 127                                      struct io_kiocb *req)
 128 {
 129         struct io_uring_cqe *cqe;
 130
 131         /*
 132          * If we can't get a cq entry, userspace overflowed the
 133          * submission (by quite a lot). Increment the overflow count in
 134          * the ring.
 135          */
 136         cqe = io_get_cqe(ctx);
 137         if (unlikely(!cqe))
 138                 return false;
 139
 140         trace_io_uring_complete(req->ctx, req, req->cqe.user_data,
 141                                 req->cqe.res, req->cqe.flags,
 142                                 (req->flags & REQ_F_CQE32_INIT) ? req->extra1 : 0,
 143                                 (req->flags & REQ_F_CQE32_INIT) ? req->extra2 : 0);
 144
 145         memcpy(cqe, &req->cqe, sizeof(*cqe));
 146
 147         if (ctx->flags & IORING_SETUP_CQE32) {
 148                 u64 extra1 = 0, extra2 = 0;
 149
 150                 if (req->flags & REQ_F_CQE32_INIT) {
 151                         extra1 = req->extra1;
 152                         extra2 = req->extra2;
 153                 }
 154
 155                 WRITE_ONCE(cqe->big_cqe[0], extra1);
 156                 WRITE_ONCE(cqe->big_cqe[1], extra2);
 157         }
 158         return true;
 159 }
 160
 161 static inline bool io_fill_cqe_req(struct io_ring_ctx *ctx,
 162                                    struct io_kiocb *req)
 163 {
 164         if (likely(__io_fill_cqe_req(ctx, req)))
 165                 return true;
 166         return io_req_cqe_overflow(req);
 167 }
 168
 169 static inline void req_set_fail(struct io_kiocb *req)
 170 {
 171         req->flags |= REQ_F_FAIL;
 172         if (req->flags & REQ_F_CQE_SKIP) {
 173                 req->flags &= ~REQ_F_CQE_SKIP;
 174                 req->flags |= REQ_F_SKIP_LINK_CQES;
 175         }
 176 }
 177
 178 static inline void io_req_set_res(struct io_kiocb *req, s32 res, u32 cflags)
 179 {
 180         req->cqe.res = res;
 181         req->cqe.flags = cflags;
 182 }
 183
 184 static inline bool req_has_async_data(struct io_kiocb *req)
 185 {
 186         return req->flags & REQ_F_ASYNC_DATA;
 187 }
 188
 189 static inline void io_put_file(struct file *file)
 190 {
 191         if (file)
 192                 fput(file);
 193 }
 194
 195 static inline void io_ring_submit_unlock(struct io_ring_ctx *ctx,
 196                                          unsigned issue_flags)
 197 {
 198         lockdep_assert_held(&ctx->uring_lock);
 199         if (issue_flags & IO_URING_F_UNLOCKED)
 200                 mutex_unlock(&ctx->uring_lock);
 201 }
 202
 203 static inline void io_ring_submit_lock(struct io_ring_ctx *ctx,
 204                                        unsigned issue_flags)
 205 {
 206         /*
 207          * "Normal" inline submissions always hold the uring_lock, since we
 208          * grab it from the system call. Same is true for the SQPOLL offload.
 209          * The only exception is when we've detached the request and issue it
 210          * from an async worker thread, grab the lock for that case.
 211          */
 212         if (issue_flags & IO_URING_F_UNLOCKED)
 213                 mutex_lock(&ctx->uring_lock);
 214         lockdep_assert_held(&ctx->uring_lock);
 215 }
 216
 217 static inline void io_commit_cqring(struct io_ring_ctx *ctx)
 218 {
 219         /* order cqe stores with ring update */
 220         smp_store_release(&ctx->rings->cq.tail, ctx->cached_cq_tail);
 221 }
 222
 223 /* requires smb_mb() prior, see wq_has_sleeper() */
 224 static inline void __io_cqring_wake(struct io_ring_ctx *ctx)
 225 {
 226         /*
 227          * Trigger waitqueue handler on all waiters on our waitqueue. This
 228          * won't necessarily wake up all the tasks, io_should_wake() will make
 229          * that decision.
 230          *
 231          * Pass in EPOLLIN|EPOLL_URING_WAKE as the poll wakeup key. The latter
 232          * set in the mask so that if we recurse back into our own poll
 233          * waitqueue handlers, we know we have a dependency between eventfd or
 234          * epoll and should terminate multishot poll at that point.
 235          */
 236         if (waitqueue_active(&ctx->cq_wait))
 237                 __wake_up(&ctx->cq_wait, TASK_NORMAL, 0,
 238                                 poll_to_key(EPOLL_URING_WAKE | EPOLLIN));
 239 }
 240
 241 static inline void io_cqring_wake(struct io_ring_ctx *ctx)
 242 {
 243         smp_mb();
 244         __io_cqring_wake(ctx);
 245 }
 246
 247 static inline bool io_sqring_full(struct io_ring_ctx *ctx)
 248 {
 249         struct io_rings *r = ctx->rings;
 250
 251         return READ_ONCE(r->sq.tail) - ctx->cached_sq_head == ctx->sq_entries;
 252 }
 253
 254 static inline unsigned int io_sqring_entries(struct io_ring_ctx *ctx)
 255 {
 256         struct io_rings *rings = ctx->rings;
 257
 258         /* make sure SQ entry isn't read before tail */
 259         return smp_load_acquire(&rings->sq.tail) - ctx->cached_sq_head;
 260 }
 261
 262 static inline int io_run_task_work(void)
 263 {
 264         /*
 265          * Always check-and-clear the task_work notification signal. With how
 266          * signaling works for task_work, we can find it set with nothing to
 267          * run. We need to clear it for that case, like get_signal() does.
 268          */
 269         if (test_thread_flag(TIF_NOTIFY_SIGNAL))
 270                 clear_notify_signal();
 271         if (task_work_pending(current)) {
 272                 __set_current_state(TASK_RUNNING);
 273                 task_work_run();
 274                 return 1;
 275         }
 276
 277         return 0;
 278 }
 279
 280 static inline bool io_task_work_pending(struct io_ring_ctx *ctx)
 281 {
 282         return task_work_pending(current) || !wq_list_empty(&ctx->work_llist);
 283 }
 284
 285 static inline void io_tw_lock(struct io_ring_ctx *ctx, bool *locked)
 286 {
 287         if (!*locked) {
 288                 mutex_lock(&ctx->uring_lock);
 289                 *locked = true;
 290         }
 291 }
 292
 293 /*
 294  * Don't complete immediately but use deferred completion infrastructure.
 295  * Protected by ->uring_lock and can only be used either with
 296  * IO_URING_F_COMPLETE_DEFER or inside a tw handler holding the mutex.
 297  */
 298 static inline void io_req_complete_defer(struct io_kiocb *req)
 299         __must_hold(&req->ctx->uring_lock)
 300 {
 301         struct io_submit_state *state = &req->ctx->submit_state;
 302
 303         lockdep_assert_held(&req->ctx->uring_lock);
 304
 305         wq_list_add_tail(&req->comp_list, &state->compl_reqs);
 306 }
 307
 308 static inline void io_commit_cqring_flush(struct io_ring_ctx *ctx)
 309 {
 310         if (unlikely(ctx->off_timeout_used || ctx->drain_active || ctx->has_evfd))
 311                 __io_commit_cqring_flush(ctx);
 312 }
 313
 314 /* must to be called somewhat shortly after putting a request */
 315 static inline void io_put_task(struct task_struct *task, int nr)
 316 {
 317         if (likely(task == current))
 318                 task->io_uring->cached_refs += nr;
 319         else
 320                 __io_put_task(task, nr);
 321 }
 322
 323 static inline void io_get_task_refs(int nr)
 324 {
 325         struct io_uring_task *tctx = current->io_uring;
 326
 327         tctx->cached_refs -= nr;
 328         if (unlikely(tctx->cached_refs < 0))
 329                 io_task_refs_refill(tctx);
 330 }
 331
 332 static inline bool io_req_cache_empty(struct io_ring_ctx *ctx)
 333 {
 334         return !ctx->submit_state.free_list.next;
 335 }
 336
 337 static inline bool io_alloc_req_refill(struct io_ring_ctx *ctx)
 338 {
 339         if (unlikely(io_req_cache_empty(ctx)))
 340                 return __io_alloc_req_refill(ctx);
 341         return true;
 342 }
 343
 344 static inline struct io_kiocb *io_alloc_req(struct io_ring_ctx *ctx)
 345 {
 346         struct io_wq_work_node *node;
 347
 348         node = wq_stack_extract(&ctx->submit_state.free_list);
 349         return container_of(node, struct io_kiocb, comp_list);
 350 }
 351
 352 static inline bool io_allowed_defer_tw_run(struct io_ring_ctx *ctx)
 353 {
 354         return likely(ctx->submitter_task == current);
 355 }
 356
 357 static inline bool io_allowed_run_tw(struct io_ring_ctx *ctx)
 358 {
 359         return likely(!(ctx->flags & IORING_SETUP_DEFER_TASKRUN) ||
 360                       ctx->submitter_task == current);
 361 }
 362
 363 static inline void io_req_queue_tw_complete(struct io_kiocb *req, s32 res)
 364 {
 365         io_req_set_res(req, res, 0);
 366         req->io_task_work.func = io_req_task_complete;
 367         io_req_task_work_add(req);
 368 }
 369
 370 #endif