include/trace/events/io_uring.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #undef TRACE_SYSTEM
   3 #define TRACE_SYSTEM io_uring
   4
   5 #if !defined(_TRACE_IO_URING_H) || defined(TRACE_HEADER_MULTI_READ)
   6 #define _TRACE_IO_URING_H
   7
   8 #include <linux/tracepoint.h>
   9
  10 struct io_wq_work;
  11
  12 /**
  13  * io_uring_create - called after a new io_uring context was prepared
  14  *
  15  * @fd:                 corresponding file descriptor
  16  * @ctx:                pointer to a ring context structure
  17  * @sq_entries: actual SQ size
  18  * @cq_entries: actual CQ size
  19  * @flags:              SQ ring flags, provided to io_uring_setup(2)
  20  *
  21  * Allows to trace io_uring creation and provide pointer to a context, that can
  22  * be used later to find correlated events.
  23  */
  24 TRACE_EVENT(io_uring_create,
  25
  26         TP_PROTO(int fd, void *ctx, u32 sq_entries, u32 cq_entries, u32 flags),
  27
  28         TP_ARGS(fd, ctx, sq_entries, cq_entries, flags),
  29
  30         TP_STRUCT__entry (
  31                 __field(  int,          fd                      )
  32                 __field(  void *,       ctx                     )
  33                 __field(  u32,          sq_entries      )
  34                 __field(  u32,          cq_entries      )
  35                 __field(  u32,          flags           )
  36         ),
  37
  38         TP_fast_assign(
  39                 __entry->fd                     = fd;
  40                 __entry->ctx            = ctx;
  41                 __entry->sq_entries     = sq_entries;
  42                 __entry->cq_entries     = cq_entries;
  43                 __entry->flags          = flags;
  44         ),
  45
  46         TP_printk("ring %p, fd %d sq size %d, cq size %d, flags %d",
  47                           __entry->ctx, __entry->fd, __entry->sq_entries,
  48                           __entry->cq_entries, __entry->flags)
  49 );
  50
  51 /**
  52  * io_uring_register - called after a buffer/file/eventfd was succesfully
  53  *                                         registered for a ring
  54  *
  55  * @ctx:                        pointer to a ring context structure
  56  * @opcode:                     describes which operation to perform
  57  * @nr_user_files:      number of registered files
  58  * @nr_user_bufs:       number of registered buffers
  59  * @cq_ev_fd:           whether eventfs registered or not
  60  * @ret:                        return code
  61  *
  62  * Allows to trace fixed files/buffers/eventfds, that could be registered to
  63  * avoid an overhead of getting references to them for every operation. This
  64  * event, together with io_uring_file_get, can provide a full picture of how
  65  * much overhead one can reduce via fixing.
  66  */
  67 TRACE_EVENT(io_uring_register,
  68
  69         TP_PROTO(void *ctx, unsigned opcode, unsigned nr_files,
  70                          unsigned nr_bufs, bool eventfd, long ret),
  71
  72         TP_ARGS(ctx, opcode, nr_files, nr_bufs, eventfd, ret),
  73
  74         TP_STRUCT__entry (
  75                 __field(  void *,       ctx                     )
  76                 __field(  unsigned,     opcode          )
  77                 __field(  unsigned,     nr_files        )
  78                 __field(  unsigned,     nr_bufs         )
  79                 __field(  bool,         eventfd         )
  80                 __field(  long,         ret                     )
  81         ),
  82
  83         TP_fast_assign(
  84                 __entry->ctx            = ctx;
  85                 __entry->opcode         = opcode;
  86                 __entry->nr_files       = nr_files;
  87                 __entry->nr_bufs        = nr_bufs;
  88                 __entry->eventfd        = eventfd;
  89                 __entry->ret            = ret;
  90         ),
  91
  92         TP_printk("ring %p, opcode %d, nr_user_files %d, nr_user_bufs %d, "
  93                           "eventfd %d, ret %ld",
  94                           __entry->ctx, __entry->opcode, __entry->nr_files,
  95                           __entry->nr_bufs, __entry->eventfd, __entry->ret)
  96 );
  97
  98 /**
  99  * io_uring_file_get - called before getting references to an SQE file
 100  *
 101  * @ctx:        pointer to a ring context structure
 102  * @fd:         SQE file descriptor
 103  *
 104  * Allows to trace out how often an SQE file reference is obtained, which can
 105  * help figuring out if it makes sense to use fixed files, or check that fixed
 106  * files are used correctly.
 107  */
 108 TRACE_EVENT(io_uring_file_get,
 109
 110         TP_PROTO(void *ctx, int fd),
 111
 112         TP_ARGS(ctx, fd),
 113
 114         TP_STRUCT__entry (
 115                 __field(  void *,       ctx     )
 116                 __field(  int,          fd      )
 117         ),
 118
 119         TP_fast_assign(
 120                 __entry->ctx    = ctx;
 121                 __entry->fd             = fd;
 122         ),
 123
 124         TP_printk("ring %p, fd %d", __entry->ctx, __entry->fd)
 125 );
 126
 127 /**
 128  * io_uring_queue_async_work - called before submitting a new async work
 129  *
 130  * @ctx:        pointer to a ring context structure
 131  * @hashed:     type of workqueue, hashed or normal
 132  * @req:        pointer to a submitted request
 133  * @work:       pointer to a submitted io_wq_work
 134  *
 135  * Allows to trace asynchronous work submission.
 136  */
 137 TRACE_EVENT(io_uring_queue_async_work,
 138
 139         TP_PROTO(void *ctx, int rw, void * req, struct io_wq_work *work,
 140                          unsigned int flags),
 141
 142         TP_ARGS(ctx, rw, req, work, flags),
 143
 144         TP_STRUCT__entry (
 145                 __field(  void *,                               ctx             )
 146                 __field(  int,                                  rw              )
 147                 __field(  void *,                               req             )
 148                 __field(  struct io_wq_work *,          work    )
 149                 __field(  unsigned int,                 flags   )
 150         ),
 151
 152         TP_fast_assign(
 153                 __entry->ctx    = ctx;
 154                 __entry->rw             = rw;
 155                 __entry->req    = req;
 156                 __entry->work   = work;
 157                 __entry->flags  = flags;
 158         ),
 159
 160         TP_printk("ring %p, request %p, flags %d, %s queue, work %p",
 161                           __entry->ctx, __entry->req, __entry->flags,
 162                           __entry->rw ? "hashed" : "normal", __entry->work)
 163 );
 164
 165 /**
 166  * io_uring_defer - called when an io_uring request is deferred
 167  *
 168  * @ctx:        pointer to a ring context structure
 169  * @req:        pointer to a deferred request
 170  * @user_data:  user data associated with the request
 171  *
 172  * Allows to track deferred requests, to get an insight about what requests are
 173  * not started immediately.
 174  */
 175 TRACE_EVENT(io_uring_defer,
 176
 177         TP_PROTO(void *ctx, void *req, unsigned long long user_data),
 178
 179         TP_ARGS(ctx, req, user_data),
 180
 181         TP_STRUCT__entry (
 182                 __field(  void *,       ctx             )
 183                 __field(  void *,       req             )
 184                 __field(  unsigned long long, data      )
 185         ),
 186
 187         TP_fast_assign(
 188                 __entry->ctx    = ctx;
 189                 __entry->req    = req;
 190                 __entry->data   = user_data;
 191         ),
 192
 193         TP_printk("ring %p, request %p user_data %llu", __entry->ctx,
 194                         __entry->req, __entry->data)
 195 );
 196
 197 /**
 198  * io_uring_link - called before the io_uring request added into link_list of
 199  *                                 another request
 200  *
 201  * @ctx:                        pointer to a ring context structure
 202  * @req:                        pointer to a linked request
 203  * @target_req:         pointer to a previous request, that would contain @req
 204  *
 205  * Allows to track linked requests, to understand dependencies between requests
 206  * and how does it influence their execution flow.
 207  */
 208 TRACE_EVENT(io_uring_link,
 209
 210         TP_PROTO(void *ctx, void *req, void *target_req),
 211
 212         TP_ARGS(ctx, req, target_req),
 213
 214         TP_STRUCT__entry (
 215                 __field(  void *,       ctx                     )
 216                 __field(  void *,       req                     )
 217                 __field(  void *,       target_req      )
 218         ),
 219
 220         TP_fast_assign(
 221                 __entry->ctx            = ctx;
 222                 __entry->req            = req;
 223                 __entry->target_req     = target_req;
 224         ),
 225
 226         TP_printk("ring %p, request %p linked after %p",
 227                           __entry->ctx, __entry->req, __entry->target_req)
 228 );
 229
 230 /**
 231  * io_uring_cqring_wait - called before start waiting for an available CQE
 232  *
 233  * @ctx:                pointer to a ring context structure
 234  * @min_events: minimal number of events to wait for
 235  *
 236  * Allows to track waiting for CQE, so that we can e.g. troubleshoot
 237  * situations, when an application wants to wait for an event, that never
 238  * comes.
 239  */
 240 TRACE_EVENT(io_uring_cqring_wait,
 241
 242         TP_PROTO(void *ctx, int min_events),
 243
 244         TP_ARGS(ctx, min_events),
 245
 246         TP_STRUCT__entry (
 247                 __field(  void *,       ctx                     )
 248                 __field(  int,          min_events      )
 249         ),
 250
 251         TP_fast_assign(
 252                 __entry->ctx    = ctx;
 253                 __entry->min_events     = min_events;
 254         ),
 255
 256         TP_printk("ring %p, min_events %d", __entry->ctx, __entry->min_events)
 257 );
 258
 259 /**
 260  * io_uring_fail_link - called before failing a linked request
 261  *
 262  * @req:        request, which links were cancelled
 263  * @link:       cancelled link
 264  *
 265  * Allows to track linked requests cancellation, to see not only that some work
 266  * was cancelled, but also which request was the reason.
 267  */
 268 TRACE_EVENT(io_uring_fail_link,
 269
 270         TP_PROTO(void *req, void *link),
 271
 272         TP_ARGS(req, link),
 273
 274         TP_STRUCT__entry (
 275                 __field(  void *,       req             )
 276                 __field(  void *,       link    )
 277         ),
 278
 279         TP_fast_assign(
 280                 __entry->req    = req;
 281                 __entry->link   = link;
 282         ),
 283
 284         TP_printk("request %p, link %p", __entry->req, __entry->link)
 285 );
 286
 287 /**
 288  * io_uring_complete - called when completing an SQE
 289  *
 290  * @ctx:                pointer to a ring context structure
 291  * @user_data:          user data associated with the request
 292  * @res:                result of the request
 293  *
 294  */
 295 TRACE_EVENT(io_uring_complete,
 296
 297         TP_PROTO(void *ctx, u64 user_data, long res),
 298
 299         TP_ARGS(ctx, user_data, res),
 300
 301         TP_STRUCT__entry (
 302                 __field(  void *,       ctx             )
 303                 __field(  u64,          user_data       )
 304                 __field(  long,         res             )
 305         ),
 306
 307         TP_fast_assign(
 308                 __entry->ctx            = ctx;
 309                 __entry->user_data      = user_data;
 310                 __entry->res            = res;
 311         ),
 312
 313         TP_printk("ring %p, user_data 0x%llx, result %ld",
 314                           __entry->ctx, (unsigned long long)__entry->user_data,
 315                           __entry->res)
 316 );
 317
 318
 319 /**
 320  * io_uring_submit_sqe - called before submitting one SQE
 321  *
 322  * @ctx:                pointer to a ring context structure
 323  * @opcode:             opcode of request
 324  * @user_data:          user data associated with the request
 325  * @force_nonblock:     whether a context blocking or not
 326  * @sq_thread:          true if sq_thread has submitted this SQE
 327  *
 328  * Allows to track SQE submitting, to understand what was the source of it, SQ
 329  * thread or io_uring_enter call.
 330  */
 331 TRACE_EVENT(io_uring_submit_sqe,
 332
 333         TP_PROTO(void *ctx, u8 opcode, u64 user_data, bool force_nonblock,
 334                  bool sq_thread),
 335
 336         TP_ARGS(ctx, opcode, user_data, force_nonblock, sq_thread),
 337
 338         TP_STRUCT__entry (
 339                 __field(  void *,       ctx             )
 340                 __field(  u8,           opcode          )
 341                 __field(  u64,          user_data       )
 342                 __field(  bool,         force_nonblock  )
 343                 __field(  bool,         sq_thread       )
 344         ),
 345
 346         TP_fast_assign(
 347                 __entry->ctx            = ctx;
 348                 __entry->opcode         = opcode;
 349                 __entry->user_data      = user_data;
 350                 __entry->force_nonblock = force_nonblock;
 351                 __entry->sq_thread      = sq_thread;
 352         ),
 353
 354         TP_printk("ring %p, op %d, data 0x%llx, non block %d, sq_thread %d",
 355                           __entry->ctx, __entry->opcode,
 356                           (unsigned long long) __entry->user_data,
 357                           __entry->force_nonblock, __entry->sq_thread)
 358 );
 359
 360 #endif /* _TRACE_IO_URING_H */
 361
 362 /* This part must be outside protection */
 363 #include <trace/define_trace.h>