| 1 |
|
| 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 | #include <uapi/linux/io_uring.h>
|
| 10 | #include <linux/io_uring_types.h>
|
| 11 | #include <linux/io_uring.h>
|
| 12 |
|
| 13 | struct io_wq_work;
|
| 14 |
|
| 15 | |
| 16 | * io_uring_create - called after a new io_uring context was prepared
|
| 17 | *
|
| 18 | * @fd: corresponding file descriptor
|
| 19 | * @ctx: pointer to a ring context structure
|
| 20 | * @sq_entries: actual SQ size
|
| 21 | * @cq_entries: actual CQ size
|
| 22 | * @flags: SQ ring flags, provided to io_uring_setup(2)
|
| 23 | *
|
| 24 | * Allows to trace io_uring creation and provide pointer to a context, that can
|
| 25 | * be used later to find correlated events.
|
| 26 |
|
| 27 | TRACE_EVENT(io_uring_create,
|
| 28 |
|
| 29 | TP_PROTO(int fd, void *ctx, u32 sq_entries, u32 cq_entries, u32 flags),
|
| 30 |
|
| 31 | TP_ARGS(fd, ctx, sq_entries, cq_entries, flags),
|
| 32 |
|
| 33 | TP_STRUCT__entry (
|
| 34 | __field( int, fd )
|
| 35 | __field( void *, ctx )
|
| 36 | __field( u32, sq_entries )
|
| 37 | __field( u32, cq_entries )
|
| 38 | __field( u32, flags )
|
| 39 | ),
|
| 40 |
|
| 41 | TP_fast_assign(
|
| 42 | __entry->fd = fd;
|
| 43 | __entry->ctx = ctx;
|
| 44 | __entry->sq_entries = sq_entries;
|
| 45 | __entry->cq_entries = cq_entries;
|
| 46 | __entry->flags = flags;
|
| 47 | ),
|
| 48 |
|
| 49 | TP_printk("ring %p, fd %d sq size %d, cq size %d, flags 0x%x",
|
| 50 | __entry->ctx, __entry->fd, __entry->sq_entries,
|
| 51 | __entry->cq_entries, __entry->flags)
|
| 52 | );
|
| 53 |
|
| 54 | |
| 55 | * io_uring_register - called after a buffer/file/eventfd was successfully
|
| 56 | * registered for a ring
|
| 57 | *
|
| 58 | * @ctx: pointer to a ring context structure
|
| 59 | * @opcode: describes which operation to perform
|
| 60 | * @nr_user_files: number of registered files
|
| 61 | * @nr_user_bufs: number of registered buffers
|
| 62 | * @ret: return code
|
| 63 | *
|
| 64 | * Allows to trace fixed files/buffers, that could be registered to
|
| 65 | * avoid an overhead of getting references to them for every operation. This
|
| 66 | * event, together with io_uring_file_get, can provide a full picture of how
|
| 67 | * much overhead one can reduce via fixing.
|
| 68 |
|
| 69 | TRACE_EVENT(io_uring_register,
|
| 70 |
|
| 71 | TP_PROTO(void *ctx, unsigned opcode, unsigned nr_files,
|
| 72 | unsigned nr_bufs, long ret),
|
| 73 |
|
| 74 | TP_ARGS(ctx, opcode, nr_files, nr_bufs, ret),
|
| 75 |
|
| 76 | TP_STRUCT__entry (
|
| 77 | __field( void *, ctx )
|
| 78 | __field( unsigned, opcode )
|
| 79 | __field( unsigned, nr_files)
|
| 80 | __field( unsigned, nr_bufs )
|
| 81 | __field( long, ret )
|
| 82 | ),
|
| 83 |
|
| 84 | TP_fast_assign(
|
| 85 | __entry->ctx = ctx;
|
| 86 | __entry->opcode = opcode;
|
| 87 | __entry->nr_files = nr_files;
|
| 88 | __entry->nr_bufs = nr_bufs;
|
| 89 | __entry->ret = ret;
|
| 90 | ),
|
| 91 |
|
| 92 | TP_printk("ring %p, opcode %d, nr_user_files %d, nr_user_bufs %d, "
|
| 93 | "ret %ld",
|
| 94 | __entry->ctx, __entry->opcode, __entry->nr_files,
|
| 95 | __entry->nr_bufs, __entry->ret)
|
| 96 | );
|
| 97 |
|
| 98 | |
| 99 | * io_uring_file_get - called before getting references to an SQE file
|
| 100 | *
|
| 101 | * @req: pointer to a submitted request
|
| 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(struct io_kiocb *req, int fd),
|
| 111 |
|
| 112 | TP_ARGS(req, fd),
|
| 113 |
|
| 114 | TP_STRUCT__entry (
|
| 115 | __field( void *, ctx )
|
| 116 | __field( void *, req )
|
| 117 | __field( u64, user_data )
|
| 118 | __field( int, fd )
|
| 119 | ),
|
| 120 |
|
| 121 | TP_fast_assign(
|
| 122 | __entry->ctx = req->ctx;
|
| 123 | __entry->req = req;
|
| 124 | __entry->user_data = req->cqe.user_data;
|
| 125 | __entry->fd = fd;
|
| 126 | ),
|
| 127 |
|
| 128 | TP_printk("ring %p, req %p, user_data 0x%llx, fd %d",
|
| 129 | __entry->ctx, __entry->req, __entry->user_data, __entry->fd)
|
| 130 | );
|
| 131 |
|
| 132 | |
| 133 | * io_uring_queue_async_work - called before submitting a new async work
|
| 134 | *
|
| 135 | * @req: pointer to a submitted request
|
| 136 | * @hashed: whether async work is hashed
|
| 137 | *
|
| 138 | * Allows to trace asynchronous work submission.
|
| 139 |
|
| 140 | TRACE_EVENT(io_uring_queue_async_work,
|
| 141 |
|
| 142 | TP_PROTO(struct io_kiocb *req, bool hashed),
|
| 143 |
|
| 144 | TP_ARGS(req, hashed),
|
| 145 |
|
| 146 | TP_STRUCT__entry (
|
| 147 | __field( void *, ctx )
|
| 148 | __field( void *, req )
|
| 149 | __field( u64, user_data )
|
| 150 | __field( u8, opcode )
|
| 151 | __field( unsigned long long, flags )
|
| 152 | __field( struct io_wq_work *, work )
|
| 153 | __field( bool, hashed )
|
| 154 |
|
| 155 | __string( op_str, io_uring_get_opcode(req->opcode) )
|
| 156 | ),
|
| 157 |
|
| 158 | TP_fast_assign(
|
| 159 | __entry->ctx = req->ctx;
|
| 160 | __entry->req = req;
|
| 161 | __entry->user_data = req->cqe.user_data;
|
| 162 | __entry->flags = (__force unsigned long long) req->flags;
|
| 163 | __entry->opcode = req->opcode;
|
| 164 | __entry->work = &req->work;
|
| 165 | __entry->hashed = hashed;
|
| 166 |
|
| 167 | __assign_str(op_str);
|
| 168 | ),
|
| 169 |
|
| 170 | TP_printk("ring %p, request %p, user_data 0x%llx, opcode %s, flags 0x%llx, %s queue, work %p",
|
| 171 | __entry->ctx, __entry->req, __entry->user_data,
|
| 172 | __get_str(op_str), __entry->flags,
|
| 173 | __entry->hashed ? "hashed" : "normal", __entry->work)
|
| 174 | );
|
| 175 |
|
| 176 | |
| 177 | * io_uring_defer - called when an io_uring request is deferred
|
| 178 | *
|
| 179 | * @req: pointer to a deferred request
|
| 180 | *
|
| 181 | * Allows to track deferred requests, to get an insight about what requests are
|
| 182 | * not started immediately.
|
| 183 |
|
| 184 | TRACE_EVENT(io_uring_defer,
|
| 185 |
|
| 186 | TP_PROTO(struct io_kiocb *req),
|
| 187 |
|
| 188 | TP_ARGS(req),
|
| 189 |
|
| 190 | TP_STRUCT__entry (
|
| 191 | __field( void *, ctx )
|
| 192 | __field( void *, req )
|
| 193 | __field( unsigned long long, data )
|
| 194 | __field( u8, opcode )
|
| 195 |
|
| 196 | __string( op_str, io_uring_get_opcode(req->opcode) )
|
| 197 | ),
|
| 198 |
|
| 199 | TP_fast_assign(
|
| 200 | __entry->ctx = req->ctx;
|
| 201 | __entry->req = req;
|
| 202 | __entry->data = req->cqe.user_data;
|
| 203 | __entry->opcode = req->opcode;
|
| 204 |
|
| 205 | __assign_str(op_str);
|
| 206 | ),
|
| 207 |
|
| 208 | TP_printk("ring %p, request %p, user_data 0x%llx, opcode %s",
|
| 209 | __entry->ctx, __entry->req, __entry->data,
|
| 210 | __get_str(op_str))
|
| 211 | );
|
| 212 |
|
| 213 | |
| 214 | * io_uring_link - called before the io_uring request added into link_list of
|
| 215 | * another request
|
| 216 | *
|
| 217 | * @req: pointer to a linked request
|
| 218 | * @target_req: pointer to a previous request, that would contain @req
|
| 219 | *
|
| 220 | * Allows to track linked requests, to understand dependencies between requests
|
| 221 | * and how does it influence their execution flow.
|
| 222 |
|
| 223 | TRACE_EVENT(io_uring_link,
|
| 224 |
|
| 225 | TP_PROTO(struct io_kiocb *req, struct io_kiocb *target_req),
|
| 226 |
|
| 227 | TP_ARGS(req, target_req),
|
| 228 |
|
| 229 | TP_STRUCT__entry (
|
| 230 | __field( void *, ctx )
|
| 231 | __field( void *, req )
|
| 232 | __field( void *, target_req )
|
| 233 | ),
|
| 234 |
|
| 235 | TP_fast_assign(
|
| 236 | __entry->ctx = req->ctx;
|
| 237 | __entry->req = req;
|
| 238 | __entry->target_req = target_req;
|
| 239 | ),
|
| 240 |
|
| 241 | TP_printk("ring %p, request %p linked after %p",
|
| 242 | __entry->ctx, __entry->req, __entry->target_req)
|
| 243 | );
|
| 244 |
|
| 245 | |
| 246 | * io_uring_cqring_wait - called before start waiting for an available CQE
|
| 247 | *
|
| 248 | * @ctx: pointer to a ring context structure
|
| 249 | * @min_events: minimal number of events to wait for
|
| 250 | *
|
| 251 | * Allows to track waiting for CQE, so that we can e.g. troubleshoot
|
| 252 | * situations, when an application wants to wait for an event, that never
|
| 253 | * comes.
|
| 254 |
|
| 255 | TRACE_EVENT(io_uring_cqring_wait,
|
| 256 |
|
| 257 | TP_PROTO(void *ctx, int min_events),
|
| 258 |
|
| 259 | TP_ARGS(ctx, min_events),
|
| 260 |
|
| 261 | TP_STRUCT__entry (
|
| 262 | __field( void *, ctx )
|
| 263 | __field( int, min_events )
|
| 264 | ),
|
| 265 |
|
| 266 | TP_fast_assign(
|
| 267 | __entry->ctx = ctx;
|
| 268 | __entry->min_events = min_events;
|
| 269 | ),
|
| 270 |
|
| 271 | TP_printk("ring %p, min_events %d", __entry->ctx, __entry->min_events)
|
| 272 | );
|
| 273 |
|
| 274 | |
| 275 | * io_uring_fail_link - called before failing a linked request
|
| 276 | *
|
| 277 | * @req: request, which links were cancelled
|
| 278 | * @link: cancelled link
|
| 279 | *
|
| 280 | * Allows to track linked requests cancellation, to see not only that some work
|
| 281 | * was cancelled, but also which request was the reason.
|
| 282 |
|
| 283 | TRACE_EVENT(io_uring_fail_link,
|
| 284 |
|
| 285 | TP_PROTO(struct io_kiocb *req, struct io_kiocb *link),
|
| 286 |
|
| 287 | TP_ARGS(req, link),
|
| 288 |
|
| 289 | TP_STRUCT__entry (
|
| 290 | __field( void *, ctx )
|
| 291 | __field( void *, req )
|
| 292 | __field( unsigned long long, user_data )
|
| 293 | __field( u8, opcode )
|
| 294 | __field( void *, link )
|
| 295 |
|
| 296 | __string( op_str, io_uring_get_opcode(req->opcode) )
|
| 297 | ),
|
| 298 |
|
| 299 | TP_fast_assign(
|
| 300 | __entry->ctx = req->ctx;
|
| 301 | __entry->req = req;
|
| 302 | __entry->user_data = req->cqe.user_data;
|
| 303 | __entry->opcode = req->opcode;
|
| 304 | __entry->link = link;
|
| 305 |
|
| 306 | __assign_str(op_str);
|
| 307 | ),
|
| 308 |
|
| 309 | TP_printk("ring %p, request %p, user_data 0x%llx, opcode %s, link %p",
|
| 310 | __entry->ctx, __entry->req, __entry->user_data,
|
| 311 | __get_str(op_str), __entry->link)
|
| 312 | );
|
| 313 |
|
| 314 | |
| 315 | * io_uring_complete - called when completing an SQE
|
| 316 | *
|
| 317 | * @ctx: pointer to a ring context structure
|
| 318 | * @req: (optional) pointer to a submitted request
|
| 319 | * @cqe: pointer to the filled in CQE being posted
|
| 320 |
|
| 321 | TRACE_EVENT(io_uring_complete,
|
| 322 |
|
| 323 | TP_PROTO(struct io_ring_ctx *ctx, void *req, struct io_uring_cqe *cqe),
|
| 324 |
|
| 325 | TP_ARGS(ctx, req, cqe),
|
| 326 |
|
| 327 | TP_STRUCT__entry (
|
| 328 | __field( void *, ctx )
|
| 329 | __field( void *, req )
|
| 330 | __field( u64, user_data )
|
| 331 | __field( int, res )
|
| 332 | __field( unsigned, cflags )
|
| 333 | __field( u64, extra1 )
|
| 334 | __field( u64, extra2 )
|
| 335 | ),
|
| 336 |
|
| 337 | TP_fast_assign(
|
| 338 | __entry->ctx = ctx;
|
| 339 | __entry->req = req;
|
| 340 | __entry->user_data = cqe->user_data;
|
| 341 | __entry->res = cqe->res;
|
| 342 | __entry->cflags = cqe->flags;
|
| 343 | __entry->extra1 = ctx->flags & IORING_SETUP_CQE32 || cqe->flags & IORING_CQE_F_32 ? cqe->big_cqe[0] : 0;
|
| 344 | __entry->extra2 = ctx->flags & IORING_SETUP_CQE32 || cqe->flags & IORING_CQE_F_32 ? cqe->big_cqe[1] : 0;
|
| 345 | ),
|
| 346 |
|
| 347 | TP_printk("ring %p, req %p, user_data 0x%llx, result %d, cflags 0x%x "
|
| 348 | "extra1 %llu extra2 %llu ",
|
| 349 | __entry->ctx, __entry->req,
|
| 350 | __entry->user_data,
|
| 351 | __entry->res, __entry->cflags,
|
| 352 | (unsigned long long) __entry->extra1,
|
| 353 | (unsigned long long) __entry->extra2)
|
| 354 | );
|
| 355 |
|
| 356 | |
| 357 | * io_uring_submit_req - called before submitting a request
|
| 358 | *
|
| 359 | * @req: pointer to a submitted request
|
| 360 | *
|
| 361 | * Allows to track SQE submitting, to understand what was the source of it, SQ
|
| 362 | * thread or io_uring_enter call.
|
| 363 |
|
| 364 | TRACE_EVENT(io_uring_submit_req,
|
| 365 |
|
| 366 | TP_PROTO(struct io_kiocb *req),
|
| 367 |
|
| 368 | TP_ARGS(req),
|
| 369 |
|
| 370 | TP_STRUCT__entry (
|
| 371 | __field( void *, ctx )
|
| 372 | __field( void *, req )
|
| 373 | __field( unsigned long long, user_data )
|
| 374 | __field( u8, opcode )
|
| 375 | __field( unsigned long long, flags )
|
| 376 | __field( bool, sq_thread )
|
| 377 |
|
| 378 | __string( op_str, io_uring_get_opcode(req->opcode) )
|
| 379 | ),
|
| 380 |
|
| 381 | TP_fast_assign(
|
| 382 | __entry->ctx = req->ctx;
|
| 383 | __entry->req = req;
|
| 384 | __entry->user_data = req->cqe.user_data;
|
| 385 | __entry->opcode = req->opcode;
|
| 386 | __entry->flags = (__force unsigned long long) req->flags;
|
| 387 | __entry->sq_thread = req->ctx->flags & IORING_SETUP_SQPOLL;
|
| 388 |
|
| 389 | __assign_str(op_str);
|
| 390 | ),
|
| 391 |
|
| 392 | TP_printk("ring %p, req %p, user_data 0x%llx, opcode %s, flags 0x%llx, "
|
| 393 | "sq_thread %d", __entry->ctx, __entry->req,
|
| 394 | __entry->user_data, __get_str(op_str), __entry->flags,
|
| 395 | __entry->sq_thread)
|
| 396 | );
|
| 397 |
|
| 398 | |
| 399 | * io_uring_poll_arm - called after arming a poll wait if successful
|
| 400 | *
|
| 401 | * @req: pointer to the armed request
|
| 402 | * @mask: request poll events mask
|
| 403 | * @events: registered events of interest
|
| 404 | *
|
| 405 | * Allows to track which fds are waiting for and what are the events of
|
| 406 | * interest.
|
| 407 |
|
| 408 | TRACE_EVENT(io_uring_poll_arm,
|
| 409 |
|
| 410 | TP_PROTO(struct io_kiocb *req, int mask, int events),
|
| 411 |
|
| 412 | TP_ARGS(req, mask, events),
|
| 413 |
|
| 414 | TP_STRUCT__entry (
|
| 415 | __field( void *, ctx )
|
| 416 | __field( void *, req )
|
| 417 | __field( unsigned long long, user_data )
|
| 418 | __field( u8, opcode )
|
| 419 | __field( int, mask )
|
| 420 | __field( int, events )
|
| 421 |
|
| 422 | __string( op_str, io_uring_get_opcode(req->opcode) )
|
| 423 | ),
|
| 424 |
|
| 425 | TP_fast_assign(
|
| 426 | __entry->ctx = req->ctx;
|
| 427 | __entry->req = req;
|
| 428 | __entry->user_data = req->cqe.user_data;
|
| 429 | __entry->opcode = req->opcode;
|
| 430 | __entry->mask = mask;
|
| 431 | __entry->events = events;
|
| 432 |
|
| 433 | __assign_str(op_str);
|
| 434 | ),
|
| 435 |
|
| 436 | TP_printk("ring %p, req %p, user_data 0x%llx, opcode %s, mask 0x%x, events 0x%x",
|
| 437 | __entry->ctx, __entry->req, __entry->user_data,
|
| 438 | __get_str(op_str),
|
| 439 | __entry->mask, __entry->events)
|
| 440 | );
|
| 441 |
|
| 442 | |
| 443 | * io_uring_task_add - called after adding a task
|
| 444 | *
|
| 445 | * @req: pointer to request
|
| 446 | * @mask: request poll events mask
|
| 447 | *
|
| 448 |
|
| 449 | TRACE_EVENT(io_uring_task_add,
|
| 450 |
|
| 451 | TP_PROTO(struct io_kiocb *req, int mask),
|
| 452 |
|
| 453 | TP_ARGS(req, mask),
|
| 454 |
|
| 455 | TP_STRUCT__entry (
|
| 456 | __field( void *, ctx )
|
| 457 | __field( void *, req )
|
| 458 | __field( unsigned long long, user_data )
|
| 459 | __field( u8, opcode )
|
| 460 | __field( int, mask )
|
| 461 |
|
| 462 | __string( op_str, io_uring_get_opcode(req->opcode) )
|
| 463 | ),
|
| 464 |
|
| 465 | TP_fast_assign(
|
| 466 | __entry->ctx = req->ctx;
|
| 467 | __entry->req = req;
|
| 468 | __entry->user_data = req->cqe.user_data;
|
| 469 | __entry->opcode = req->opcode;
|
| 470 | __entry->mask = mask;
|
| 471 |
|
| 472 | __assign_str(op_str);
|
| 473 | ),
|
| 474 |
|
| 475 | TP_printk("ring %p, req %p, user_data 0x%llx, opcode %s, mask %x",
|
| 476 | __entry->ctx, __entry->req, __entry->user_data,
|
| 477 | __get_str(op_str),
|
| 478 | __entry->mask)
|
| 479 | );
|
| 480 |
|
| 481 | |
| 482 | * io_uring_req_failed - called when an sqe is errored dring submission
|
| 483 | *
|
| 484 | * @sqe: pointer to the io_uring_sqe that failed
|
| 485 | * @req: pointer to request
|
| 486 | * @error: error it failed with
|
| 487 | *
|
| 488 | * Allows easier diagnosing of malformed requests in production systems.
|
| 489 |
|
| 490 | TRACE_EVENT(io_uring_req_failed,
|
| 491 |
|
| 492 | TP_PROTO(const struct io_uring_sqe *sqe, struct io_kiocb *req, int error),
|
| 493 |
|
| 494 | TP_ARGS(sqe, req, error),
|
| 495 |
|
| 496 | TP_STRUCT__entry (
|
| 497 | __field( void *, ctx )
|
| 498 | __field( void *, req )
|
| 499 | __field( unsigned long long, user_data )
|
| 500 | __field( u8, opcode )
|
| 501 | __field( u8, flags )
|
| 502 | __field( u8, ioprio )
|
| 503 | __field( u64, off )
|
| 504 | __field( u64, addr )
|
| 505 | __field( u32, len )
|
| 506 | __field( u32, op_flags )
|
| 507 | __field( u16, buf_index )
|
| 508 | __field( u16, personality )
|
| 509 | __field( u32, file_index )
|
| 510 | __field( u64, pad1 )
|
| 511 | __field( u64, addr3 )
|
| 512 | __field( int, error )
|
| 513 |
|
| 514 | __string( op_str, io_uring_get_opcode(sqe->opcode) )
|
| 515 | ),
|
| 516 |
|
| 517 | TP_fast_assign(
|
| 518 | __entry->ctx = req->ctx;
|
| 519 | __entry->req = req;
|
| 520 | __entry->user_data = sqe->user_data;
|
| 521 | __entry->opcode = sqe->opcode;
|
| 522 | __entry->flags = sqe->flags;
|
| 523 | __entry->ioprio = sqe->ioprio;
|
| 524 | __entry->off = sqe->off;
|
| 525 | __entry->addr = sqe->addr;
|
| 526 | __entry->len = sqe->len;
|
| 527 | __entry->op_flags = sqe->poll32_events;
|
| 528 | __entry->buf_index = sqe->buf_index;
|
| 529 | __entry->personality = sqe->personality;
|
| 530 | __entry->file_index = sqe->file_index;
|
| 531 | __entry->pad1 = sqe->__pad2[0];
|
| 532 | __entry->addr3 = sqe->addr3;
|
| 533 | __entry->error = error;
|
| 534 |
|
| 535 | __assign_str(op_str);
|
| 536 | ),
|
| 537 |
|
| 538 | TP_printk("ring %p, req %p, user_data 0x%llx, "
|
| 539 | "opcode %s, flags 0x%x, prio=%d, off=%llu, addr=%llu, "
|
| 540 | "len=%u, rw_flags=0x%x, buf_index=%d, "
|
| 541 | "personality=%d, file_index=%d, pad=0x%llx, addr3=%llx, "
|
| 542 | "error=%d",
|
| 543 | __entry->ctx, __entry->req, __entry->user_data,
|
| 544 | __get_str(op_str),
|
| 545 | __entry->flags, __entry->ioprio,
|
| 546 | (unsigned long long)__entry->off,
|
| 547 | (unsigned long long) __entry->addr, __entry->len,
|
| 548 | __entry->op_flags,
|
| 549 | __entry->buf_index, __entry->personality, __entry->file_index,
|
| 550 | (unsigned long long) __entry->pad1,
|
| 551 | (unsigned long long) __entry->addr3, __entry->error)
|
| 552 | );
|
| 553 |
|
| 554 |
|
| 555 | |
| 556 | * io_uring_cqe_overflow - a CQE overflowed
|
| 557 | *
|
| 558 | * @ctx: pointer to a ring context structure
|
| 559 | * @user_data: user data associated with the request
|
| 560 | * @res: CQE result
|
| 561 | * @cflags: CQE flags
|
| 562 | * @ocqe: pointer to the overflow cqe (if available)
|
| 563 | *
|
| 564 |
|
| 565 | TRACE_EVENT(io_uring_cqe_overflow,
|
| 566 |
|
| 567 | TP_PROTO(void *ctx, unsigned long long user_data, s32 res, u32 cflags,
|
| 568 | void *ocqe),
|
| 569 |
|
| 570 | TP_ARGS(ctx, user_data, res, cflags, ocqe),
|
| 571 |
|
| 572 | TP_STRUCT__entry (
|
| 573 | __field( void *, ctx )
|
| 574 | __field( unsigned long long, user_data )
|
| 575 | __field( s32, res )
|
| 576 | __field( u32, cflags )
|
| 577 | __field( void *, ocqe )
|
| 578 | ),
|
| 579 |
|
| 580 | TP_fast_assign(
|
| 581 | __entry->ctx = ctx;
|
| 582 | __entry->user_data = user_data;
|
| 583 | __entry->res = res;
|
| 584 | __entry->cflags = cflags;
|
| 585 | __entry->ocqe = ocqe;
|
| 586 | ),
|
| 587 |
|
| 588 | TP_printk("ring %p, user_data 0x%llx, res %d, cflags 0x%x, "
|
| 589 | "overflow_cqe %p",
|
| 590 | __entry->ctx, __entry->user_data, __entry->res,
|
| 591 | __entry->cflags, __entry->ocqe)
|
| 592 | );
|
| 593 |
|
| 594 | |
| 595 | * io_uring_task_work_run - ran task work
|
| 596 | *
|
| 597 | * @tctx: pointer to a io_uring_task
|
| 598 | * @count: how many functions it ran
|
| 599 | *
|
| 600 |
|
| 601 | TRACE_EVENT(io_uring_task_work_run,
|
| 602 |
|
| 603 | TP_PROTO(void *tctx, unsigned int count),
|
| 604 |
|
| 605 | TP_ARGS(tctx, count),
|
| 606 |
|
| 607 | TP_STRUCT__entry (
|
| 608 | __field( void *, tctx )
|
| 609 | __field( unsigned int, count )
|
| 610 | ),
|
| 611 |
|
| 612 | TP_fast_assign(
|
| 613 | __entry->tctx = tctx;
|
| 614 | __entry->count = count;
|
| 615 | ),
|
| 616 |
|
| 617 | TP_printk("tctx %p, count %u", __entry->tctx, __entry->count)
|
| 618 | );
|
| 619 |
|
| 620 | TRACE_EVENT(io_uring_short_write,
|
| 621 |
|
| 622 | TP_PROTO(void *ctx, u64 fpos, u64 wanted, u64 got),
|
| 623 |
|
| 624 | TP_ARGS(ctx, fpos, wanted, got),
|
| 625 |
|
| 626 | TP_STRUCT__entry(
|
| 627 | __field(void *, ctx)
|
| 628 | __field(u64, fpos)
|
| 629 | __field(u64, wanted)
|
| 630 | __field(u64, got)
|
| 631 | ),
|
| 632 |
|
| 633 | TP_fast_assign(
|
| 634 | __entry->ctx = ctx;
|
| 635 | __entry->fpos = fpos;
|
| 636 | __entry->wanted = wanted;
|
| 637 | __entry->got = got;
|
| 638 | ),
|
| 639 |
|
| 640 | TP_printk("ring %p, fpos %lld, wanted %lld, got %lld",
|
| 641 | __entry->ctx, __entry->fpos,
|
| 642 | __entry->wanted, __entry->got)
|
| 643 | );
|
| 644 |
|
| 645 | |
| 646 | * io_uring_local_work_run - ran ring local task work
|
| 647 | *
|
| 648 | * @ctx: pointer to an io_ring_ctx
|
| 649 | * @count: how many functions it ran
|
| 650 | * @loops: how many loops it ran
|
| 651 | *
|
| 652 |
|
| 653 | TRACE_EVENT(io_uring_local_work_run,
|
| 654 |
|
| 655 | TP_PROTO(void *ctx, int count, unsigned int loops),
|
| 656 |
|
| 657 | TP_ARGS(ctx, count, loops),
|
| 658 |
|
| 659 | TP_STRUCT__entry (
|
| 660 | __field(void *, ctx )
|
| 661 | __field(int, count )
|
| 662 | __field(unsigned int, loops )
|
| 663 | ),
|
| 664 |
|
| 665 | TP_fast_assign(
|
| 666 | __entry->ctx = ctx;
|
| 667 | __entry->count = count;
|
| 668 | __entry->loops = loops;
|
| 669 | ),
|
| 670 |
|
| 671 | TP_printk("ring %p, count %d, loops %u", __entry->ctx, __entry->count, __entry->loops)
|
| 672 | );
|
| 673 |
|
| 674 | #endif
|
| 675 |
|
| 676 |
|
| 677 | #include <trace/define_trace.h>
|