9836e93c0a
-----BEGIN PGP SIGNATURE----- iQJEBAABCAAuFiEEwPw5LcreJtl1+l5K99NY+ylx4KYFAmKKovAQHGF4Ym9lQGtl cm5lbC5kawAKCRD301j7KXHgpv9oD/4qCs7k3bPZZWZ6xoWb4EObyyWOUifi26lp vpsJHFUbA67S/i4++LV9H18SazWJ7h08ac4bjgZ+NQz40/1WkTN8/Fa76jo+BnNK 7T10Wp4Ak6uwWVrKaA81pnT+G9+xmHlJ3X27aKxzLuT7BEPpShZ6ouFVjTkx9CzN LrLjuCDTOBBN+ZoaroWYfdLwTQX2VCAl9B15lOtQIlFvuuU8VlrvLboY+80K8TvY 1wvTA2HTjnXoYx+/cTTMIFZIwQH3r1hsbwEDD8/YJj1+ouhSRQ1b0p/nk2pA+3ws HF5r/YS/rLBjlPF094IzeOBaUyA433AN1VhZqnII8ek7ViT3W3x+BRrgE9O6ZkWT 0AjX1BXReI5rdFmxBmwsSdBnrSoGaJOf2GdsCCdubXBIi+F/RvyajrPf7PTB5zbW 9WEK/uy3xvZsRVkUGAzOb9QGdvjcllgMzwPJsDegDCw5PdcPdT3mzy6KGIWipFLp j8R+br7hRMpOJv/YpihJDMzSDkQ/r1/SCwR4fpLid/QdSHG/eRTQK6c4Su5bNYEy QDy2F6kQdBVtEJCQHcEOsbhXzSTNBcdB+ujUUM5653FkaHe6y4JbomLrsNx407Id i/4ROwA5K1dioJx503Eap+OhbI5rV+PFytJTwxvLrNyVGccwbH2YOVq80fsVBP2e cZbn6EX4Vg== =/peE -----END PGP SIGNATURE----- Merge tag 'for-5.19/io_uring-passthrough-2022-05-22' of git://git.kernel.dk/linux-block Pull io_uring NVMe command passthrough from Jens Axboe: "On top of everything else, this adds support for passthrough for io_uring. The initial feature for this is NVMe passthrough support, which allows non-filesystem based IO commands and admin commands. To support this, io_uring grows support for SQE and CQE members that are twice as big, allowing to pass in a full NVMe command without having to copy data around. And to complete with more than just a single 32-bit value as the output" * tag 'for-5.19/io_uring-passthrough-2022-05-22' of git://git.kernel.dk/linux-block: (22 commits) io_uring: cleanup handling of the two task_work lists nvme: enable uring-passthrough for admin commands nvme: helper for uring-passthrough checks blk-mq: fix passthrough plugging nvme: add vectored-io support for uring-cmd nvme: wire-up uring-cmd support for io-passthru on char-device. nvme: refactor nvme_submit_user_cmd() block: wire-up support for passthrough plugging fs,io_uring: add infrastructure for uring-cmd io_uring: support CQE32 for nop operation io_uring: enable CQE32 io_uring: support CQE32 in /proc info io_uring: add tracing for additional CQE32 fields io_uring: overflow processing for CQE32 io_uring: flush completions for CQE32 io_uring: modify io_get_cqe for CQE32 io_uring: add CQE32 completion processing io_uring: add CQE32 setup processing io_uring: change ring size calculation for CQE32 io_uring: store add. return values for CQE32 ...
606 lines
16 KiB
C
606 lines
16 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
#undef TRACE_SYSTEM
|
|
#define TRACE_SYSTEM io_uring
|
|
|
|
#if !defined(_TRACE_IO_URING_H) || defined(TRACE_HEADER_MULTI_READ)
|
|
#define _TRACE_IO_URING_H
|
|
|
|
#include <linux/tracepoint.h>
|
|
#include <uapi/linux/io_uring.h>
|
|
#include <linux/io_uring.h>
|
|
|
|
struct io_wq_work;
|
|
|
|
/**
|
|
* io_uring_create - called after a new io_uring context was prepared
|
|
*
|
|
* @fd: corresponding file descriptor
|
|
* @ctx: pointer to a ring context structure
|
|
* @sq_entries: actual SQ size
|
|
* @cq_entries: actual CQ size
|
|
* @flags: SQ ring flags, provided to io_uring_setup(2)
|
|
*
|
|
* Allows to trace io_uring creation and provide pointer to a context, that can
|
|
* be used later to find correlated events.
|
|
*/
|
|
TRACE_EVENT(io_uring_create,
|
|
|
|
TP_PROTO(int fd, void *ctx, u32 sq_entries, u32 cq_entries, u32 flags),
|
|
|
|
TP_ARGS(fd, ctx, sq_entries, cq_entries, flags),
|
|
|
|
TP_STRUCT__entry (
|
|
__field( int, fd )
|
|
__field( void *, ctx )
|
|
__field( u32, sq_entries )
|
|
__field( u32, cq_entries )
|
|
__field( u32, flags )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->fd = fd;
|
|
__entry->ctx = ctx;
|
|
__entry->sq_entries = sq_entries;
|
|
__entry->cq_entries = cq_entries;
|
|
__entry->flags = flags;
|
|
),
|
|
|
|
TP_printk("ring %p, fd %d sq size %d, cq size %d, flags 0x%x",
|
|
__entry->ctx, __entry->fd, __entry->sq_entries,
|
|
__entry->cq_entries, __entry->flags)
|
|
);
|
|
|
|
/**
|
|
* io_uring_register - called after a buffer/file/eventfd was successfully
|
|
* registered for a ring
|
|
*
|
|
* @ctx: pointer to a ring context structure
|
|
* @opcode: describes which operation to perform
|
|
* @nr_user_files: number of registered files
|
|
* @nr_user_bufs: number of registered buffers
|
|
* @ret: return code
|
|
*
|
|
* Allows to trace fixed files/buffers, that could be registered to
|
|
* avoid an overhead of getting references to them for every operation. This
|
|
* event, together with io_uring_file_get, can provide a full picture of how
|
|
* much overhead one can reduce via fixing.
|
|
*/
|
|
TRACE_EVENT(io_uring_register,
|
|
|
|
TP_PROTO(void *ctx, unsigned opcode, unsigned nr_files,
|
|
unsigned nr_bufs, long ret),
|
|
|
|
TP_ARGS(ctx, opcode, nr_files, nr_bufs, ret),
|
|
|
|
TP_STRUCT__entry (
|
|
__field( void *, ctx )
|
|
__field( unsigned, opcode )
|
|
__field( unsigned, nr_files)
|
|
__field( unsigned, nr_bufs )
|
|
__field( long, ret )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->ctx = ctx;
|
|
__entry->opcode = opcode;
|
|
__entry->nr_files = nr_files;
|
|
__entry->nr_bufs = nr_bufs;
|
|
__entry->ret = ret;
|
|
),
|
|
|
|
TP_printk("ring %p, opcode %d, nr_user_files %d, nr_user_bufs %d, "
|
|
"ret %ld",
|
|
__entry->ctx, __entry->opcode, __entry->nr_files,
|
|
__entry->nr_bufs, __entry->ret)
|
|
);
|
|
|
|
/**
|
|
* io_uring_file_get - called before getting references to an SQE file
|
|
*
|
|
* @ctx: pointer to a ring context structure
|
|
* @req: pointer to a submitted request
|
|
* @user_data: user data associated with the request
|
|
* @fd: SQE file descriptor
|
|
*
|
|
* Allows to trace out how often an SQE file reference is obtained, which can
|
|
* help figuring out if it makes sense to use fixed files, or check that fixed
|
|
* files are used correctly.
|
|
*/
|
|
TRACE_EVENT(io_uring_file_get,
|
|
|
|
TP_PROTO(void *ctx, void *req, unsigned long long user_data, int fd),
|
|
|
|
TP_ARGS(ctx, req, user_data, fd),
|
|
|
|
TP_STRUCT__entry (
|
|
__field( void *, ctx )
|
|
__field( void *, req )
|
|
__field( u64, user_data )
|
|
__field( int, fd )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->ctx = ctx;
|
|
__entry->req = req;
|
|
__entry->user_data = user_data;
|
|
__entry->fd = fd;
|
|
),
|
|
|
|
TP_printk("ring %p, req %p, user_data 0x%llx, fd %d",
|
|
__entry->ctx, __entry->req, __entry->user_data, __entry->fd)
|
|
);
|
|
|
|
/**
|
|
* io_uring_queue_async_work - called before submitting a new async work
|
|
*
|
|
* @ctx: pointer to a ring context structure
|
|
* @req: pointer to a submitted request
|
|
* @user_data: user data associated with the request
|
|
* @opcode: opcode of request
|
|
* @flags request flags
|
|
* @work: pointer to a submitted io_wq_work
|
|
* @rw: type of workqueue, hashed or normal
|
|
*
|
|
* Allows to trace asynchronous work submission.
|
|
*/
|
|
TRACE_EVENT(io_uring_queue_async_work,
|
|
|
|
TP_PROTO(void *ctx, void * req, unsigned long long user_data, u8 opcode,
|
|
unsigned int flags, struct io_wq_work *work, int rw),
|
|
|
|
TP_ARGS(ctx, req, user_data, opcode, flags, work, rw),
|
|
|
|
TP_STRUCT__entry (
|
|
__field( void *, ctx )
|
|
__field( void *, req )
|
|
__field( u64, user_data )
|
|
__field( u8, opcode )
|
|
__field( unsigned int, flags )
|
|
__field( struct io_wq_work *, work )
|
|
__field( int, rw )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->ctx = ctx;
|
|
__entry->req = req;
|
|
__entry->user_data = user_data;
|
|
__entry->flags = flags;
|
|
__entry->opcode = opcode;
|
|
__entry->work = work;
|
|
__entry->rw = rw;
|
|
),
|
|
|
|
TP_printk("ring %p, request %p, user_data 0x%llx, opcode %s, flags 0x%x, %s queue, work %p",
|
|
__entry->ctx, __entry->req, __entry->user_data,
|
|
io_uring_get_opcode(__entry->opcode),
|
|
__entry->flags, __entry->rw ? "hashed" : "normal", __entry->work)
|
|
);
|
|
|
|
/**
|
|
* io_uring_defer - called when an io_uring request is deferred
|
|
*
|
|
* @ctx: pointer to a ring context structure
|
|
* @req: pointer to a deferred request
|
|
* @user_data: user data associated with the request
|
|
* @opcode: opcode of request
|
|
*
|
|
* Allows to track deferred requests, to get an insight about what requests are
|
|
* not started immediately.
|
|
*/
|
|
TRACE_EVENT(io_uring_defer,
|
|
|
|
TP_PROTO(void *ctx, void *req, unsigned long long user_data, u8 opcode),
|
|
|
|
TP_ARGS(ctx, req, user_data, opcode),
|
|
|
|
TP_STRUCT__entry (
|
|
__field( void *, ctx )
|
|
__field( void *, req )
|
|
__field( unsigned long long, data )
|
|
__field( u8, opcode )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->ctx = ctx;
|
|
__entry->req = req;
|
|
__entry->data = user_data;
|
|
__entry->opcode = opcode;
|
|
),
|
|
|
|
TP_printk("ring %p, request %p, user_data 0x%llx, opcode %s",
|
|
__entry->ctx, __entry->req, __entry->data,
|
|
io_uring_get_opcode(__entry->opcode))
|
|
);
|
|
|
|
/**
|
|
* io_uring_link - called before the io_uring request added into link_list of
|
|
* another request
|
|
*
|
|
* @ctx: pointer to a ring context structure
|
|
* @req: pointer to a linked request
|
|
* @target_req: pointer to a previous request, that would contain @req
|
|
*
|
|
* Allows to track linked requests, to understand dependencies between requests
|
|
* and how does it influence their execution flow.
|
|
*/
|
|
TRACE_EVENT(io_uring_link,
|
|
|
|
TP_PROTO(void *ctx, void *req, void *target_req),
|
|
|
|
TP_ARGS(ctx, req, target_req),
|
|
|
|
TP_STRUCT__entry (
|
|
__field( void *, ctx )
|
|
__field( void *, req )
|
|
__field( void *, target_req )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->ctx = ctx;
|
|
__entry->req = req;
|
|
__entry->target_req = target_req;
|
|
),
|
|
|
|
TP_printk("ring %p, request %p linked after %p",
|
|
__entry->ctx, __entry->req, __entry->target_req)
|
|
);
|
|
|
|
/**
|
|
* io_uring_cqring_wait - called before start waiting for an available CQE
|
|
*
|
|
* @ctx: pointer to a ring context structure
|
|
* @min_events: minimal number of events to wait for
|
|
*
|
|
* Allows to track waiting for CQE, so that we can e.g. troubleshoot
|
|
* situations, when an application wants to wait for an event, that never
|
|
* comes.
|
|
*/
|
|
TRACE_EVENT(io_uring_cqring_wait,
|
|
|
|
TP_PROTO(void *ctx, int min_events),
|
|
|
|
TP_ARGS(ctx, min_events),
|
|
|
|
TP_STRUCT__entry (
|
|
__field( void *, ctx )
|
|
__field( int, min_events )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->ctx = ctx;
|
|
__entry->min_events = min_events;
|
|
),
|
|
|
|
TP_printk("ring %p, min_events %d", __entry->ctx, __entry->min_events)
|
|
);
|
|
|
|
/**
|
|
* io_uring_fail_link - called before failing a linked request
|
|
*
|
|
* @ctx: pointer to a ring context structure
|
|
* @req: request, which links were cancelled
|
|
* @user_data: user data associated with the request
|
|
* @opcode: opcode of request
|
|
* @link: cancelled link
|
|
*
|
|
* Allows to track linked requests cancellation, to see not only that some work
|
|
* was cancelled, but also which request was the reason.
|
|
*/
|
|
TRACE_EVENT(io_uring_fail_link,
|
|
|
|
TP_PROTO(void *ctx, void *req, unsigned long long user_data, u8 opcode, void *link),
|
|
|
|
TP_ARGS(ctx, req, user_data, opcode, link),
|
|
|
|
TP_STRUCT__entry (
|
|
__field( void *, ctx )
|
|
__field( void *, req )
|
|
__field( unsigned long long, user_data )
|
|
__field( u8, opcode )
|
|
__field( void *, link )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->ctx = ctx;
|
|
__entry->req = req;
|
|
__entry->user_data = user_data;
|
|
__entry->opcode = opcode;
|
|
__entry->link = link;
|
|
),
|
|
|
|
TP_printk("ring %p, request %p, user_data 0x%llx, opcode %s, link %p",
|
|
__entry->ctx, __entry->req, __entry->user_data,
|
|
io_uring_get_opcode(__entry->opcode), __entry->link)
|
|
);
|
|
|
|
/**
|
|
* io_uring_complete - called when completing an SQE
|
|
*
|
|
* @ctx: pointer to a ring context structure
|
|
* @req: pointer to a submitted request
|
|
* @user_data: user data associated with the request
|
|
* @res: result of the request
|
|
* @cflags: completion flags
|
|
* @extra1: extra 64-bit data for CQE32
|
|
* @extra2: extra 64-bit data for CQE32
|
|
*
|
|
*/
|
|
TRACE_EVENT(io_uring_complete,
|
|
|
|
TP_PROTO(void *ctx, void *req, u64 user_data, int res, unsigned cflags,
|
|
u64 extra1, u64 extra2),
|
|
|
|
TP_ARGS(ctx, req, user_data, res, cflags, extra1, extra2),
|
|
|
|
TP_STRUCT__entry (
|
|
__field( void *, ctx )
|
|
__field( void *, req )
|
|
__field( u64, user_data )
|
|
__field( int, res )
|
|
__field( unsigned, cflags )
|
|
__field( u64, extra1 )
|
|
__field( u64, extra2 )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->ctx = ctx;
|
|
__entry->req = req;
|
|
__entry->user_data = user_data;
|
|
__entry->res = res;
|
|
__entry->cflags = cflags;
|
|
__entry->extra1 = extra1;
|
|
__entry->extra2 = extra2;
|
|
),
|
|
|
|
TP_printk("ring %p, req %p, user_data 0x%llx, result %d, cflags 0x%x "
|
|
"extra1 %llu extra2 %llu ",
|
|
__entry->ctx, __entry->req,
|
|
__entry->user_data,
|
|
__entry->res, __entry->cflags,
|
|
(unsigned long long) __entry->extra1,
|
|
(unsigned long long) __entry->extra2)
|
|
);
|
|
|
|
/**
|
|
* io_uring_submit_sqe - called before submitting one SQE
|
|
*
|
|
* @ctx: pointer to a ring context structure
|
|
* @req: pointer to a submitted request
|
|
* @user_data: user data associated with the request
|
|
* @opcode: opcode of request
|
|
* @flags request flags
|
|
* @force_nonblock: whether a context blocking or not
|
|
* @sq_thread: true if sq_thread has submitted this SQE
|
|
*
|
|
* Allows to track SQE submitting, to understand what was the source of it, SQ
|
|
* thread or io_uring_enter call.
|
|
*/
|
|
TRACE_EVENT(io_uring_submit_sqe,
|
|
|
|
TP_PROTO(void *ctx, void *req, unsigned long long user_data, u8 opcode, u32 flags,
|
|
bool force_nonblock, bool sq_thread),
|
|
|
|
TP_ARGS(ctx, req, user_data, opcode, flags, force_nonblock, sq_thread),
|
|
|
|
TP_STRUCT__entry (
|
|
__field( void *, ctx )
|
|
__field( void *, req )
|
|
__field( unsigned long long, user_data )
|
|
__field( u8, opcode )
|
|
__field( u32, flags )
|
|
__field( bool, force_nonblock )
|
|
__field( bool, sq_thread )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->ctx = ctx;
|
|
__entry->req = req;
|
|
__entry->user_data = user_data;
|
|
__entry->opcode = opcode;
|
|
__entry->flags = flags;
|
|
__entry->force_nonblock = force_nonblock;
|
|
__entry->sq_thread = sq_thread;
|
|
),
|
|
|
|
TP_printk("ring %p, req %p, user_data 0x%llx, opcode %s, flags 0x%x, "
|
|
"non block %d, sq_thread %d", __entry->ctx, __entry->req,
|
|
__entry->user_data, io_uring_get_opcode(__entry->opcode),
|
|
__entry->flags, __entry->force_nonblock, __entry->sq_thread)
|
|
);
|
|
|
|
/*
|
|
* io_uring_poll_arm - called after arming a poll wait if successful
|
|
*
|
|
* @ctx: pointer to a ring context structure
|
|
* @req: pointer to the armed request
|
|
* @user_data: user data associated with the request
|
|
* @opcode: opcode of request
|
|
* @mask: request poll events mask
|
|
* @events: registered events of interest
|
|
*
|
|
* Allows to track which fds are waiting for and what are the events of
|
|
* interest.
|
|
*/
|
|
TRACE_EVENT(io_uring_poll_arm,
|
|
|
|
TP_PROTO(void *ctx, void *req, u64 user_data, u8 opcode,
|
|
int mask, int events),
|
|
|
|
TP_ARGS(ctx, req, user_data, opcode, mask, events),
|
|
|
|
TP_STRUCT__entry (
|
|
__field( void *, ctx )
|
|
__field( void *, req )
|
|
__field( unsigned long long, user_data )
|
|
__field( u8, opcode )
|
|
__field( int, mask )
|
|
__field( int, events )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->ctx = ctx;
|
|
__entry->req = req;
|
|
__entry->user_data = user_data;
|
|
__entry->opcode = opcode;
|
|
__entry->mask = mask;
|
|
__entry->events = events;
|
|
),
|
|
|
|
TP_printk("ring %p, req %p, user_data 0x%llx, opcode %s, mask 0x%x, events 0x%x",
|
|
__entry->ctx, __entry->req, __entry->user_data,
|
|
io_uring_get_opcode(__entry->opcode),
|
|
__entry->mask, __entry->events)
|
|
);
|
|
|
|
/*
|
|
* io_uring_task_add - called after adding a task
|
|
*
|
|
* @ctx: pointer to a ring context structure
|
|
* @req: pointer to request
|
|
* @user_data: user data associated with the request
|
|
* @opcode: opcode of request
|
|
* @mask: request poll events mask
|
|
*
|
|
*/
|
|
TRACE_EVENT(io_uring_task_add,
|
|
|
|
TP_PROTO(void *ctx, void *req, unsigned long long user_data, u8 opcode, int mask),
|
|
|
|
TP_ARGS(ctx, req, user_data, opcode, mask),
|
|
|
|
TP_STRUCT__entry (
|
|
__field( void *, ctx )
|
|
__field( void *, req )
|
|
__field( unsigned long long, user_data )
|
|
__field( u8, opcode )
|
|
__field( int, mask )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->ctx = ctx;
|
|
__entry->req = req;
|
|
__entry->user_data = user_data;
|
|
__entry->opcode = opcode;
|
|
__entry->mask = mask;
|
|
),
|
|
|
|
TP_printk("ring %p, req %p, user_data 0x%llx, opcode %s, mask %x",
|
|
__entry->ctx, __entry->req, __entry->user_data,
|
|
io_uring_get_opcode(__entry->opcode),
|
|
__entry->mask)
|
|
);
|
|
|
|
/*
|
|
* io_uring_req_failed - called when an sqe is errored dring submission
|
|
*
|
|
* @sqe: pointer to the io_uring_sqe that failed
|
|
* @ctx: pointer to a ring context structure
|
|
* @req: pointer to request
|
|
* @error: error it failed with
|
|
*
|
|
* Allows easier diagnosing of malformed requests in production systems.
|
|
*/
|
|
TRACE_EVENT(io_uring_req_failed,
|
|
|
|
TP_PROTO(const struct io_uring_sqe *sqe, void *ctx, void *req, int error),
|
|
|
|
TP_ARGS(sqe, ctx, req, error),
|
|
|
|
TP_STRUCT__entry (
|
|
__field( void *, ctx )
|
|
__field( void *, req )
|
|
__field( unsigned long long, user_data )
|
|
__field( u8, opcode )
|
|
__field( u8, flags )
|
|
__field( u8, ioprio )
|
|
__field( u64, off )
|
|
__field( u64, addr )
|
|
__field( u32, len )
|
|
__field( u32, op_flags )
|
|
__field( u16, buf_index )
|
|
__field( u16, personality )
|
|
__field( u32, file_index )
|
|
__field( u64, pad1 )
|
|
__field( u64, addr3 )
|
|
__field( int, error )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->ctx = ctx;
|
|
__entry->req = req;
|
|
__entry->user_data = sqe->user_data;
|
|
__entry->opcode = sqe->opcode;
|
|
__entry->flags = sqe->flags;
|
|
__entry->ioprio = sqe->ioprio;
|
|
__entry->off = sqe->off;
|
|
__entry->addr = sqe->addr;
|
|
__entry->len = sqe->len;
|
|
__entry->op_flags = sqe->poll32_events;
|
|
__entry->buf_index = sqe->buf_index;
|
|
__entry->personality = sqe->personality;
|
|
__entry->file_index = sqe->file_index;
|
|
__entry->pad1 = sqe->__pad2[0];
|
|
__entry->addr3 = sqe->addr3;
|
|
__entry->error = error;
|
|
),
|
|
|
|
TP_printk("ring %p, req %p, user_data 0x%llx, "
|
|
"opcode %s, flags 0x%x, prio=%d, off=%llu, addr=%llu, "
|
|
"len=%u, rw_flags=0x%x, buf_index=%d, "
|
|
"personality=%d, file_index=%d, pad=0x%llx, addr3=%llx, "
|
|
"error=%d",
|
|
__entry->ctx, __entry->req, __entry->user_data,
|
|
io_uring_get_opcode(__entry->opcode),
|
|
__entry->flags, __entry->ioprio,
|
|
(unsigned long long)__entry->off,
|
|
(unsigned long long) __entry->addr, __entry->len,
|
|
__entry->op_flags,
|
|
__entry->buf_index, __entry->personality, __entry->file_index,
|
|
(unsigned long long) __entry->pad1,
|
|
(unsigned long long) __entry->addr3, __entry->error)
|
|
);
|
|
|
|
|
|
/*
|
|
* io_uring_cqe_overflow - a CQE overflowed
|
|
*
|
|
* @ctx: pointer to a ring context structure
|
|
* @user_data: user data associated with the request
|
|
* @res: CQE result
|
|
* @cflags: CQE flags
|
|
* @ocqe: pointer to the overflow cqe (if available)
|
|
*
|
|
*/
|
|
TRACE_EVENT(io_uring_cqe_overflow,
|
|
|
|
TP_PROTO(void *ctx, unsigned long long user_data, s32 res, u32 cflags,
|
|
void *ocqe),
|
|
|
|
TP_ARGS(ctx, user_data, res, cflags, ocqe),
|
|
|
|
TP_STRUCT__entry (
|
|
__field( void *, ctx )
|
|
__field( unsigned long long, user_data )
|
|
__field( s32, res )
|
|
__field( u32, cflags )
|
|
__field( void *, ocqe )
|
|
),
|
|
|
|
TP_fast_assign(
|
|
__entry->ctx = ctx;
|
|
__entry->user_data = user_data;
|
|
__entry->res = res;
|
|
__entry->cflags = cflags;
|
|
__entry->ocqe = ocqe;
|
|
),
|
|
|
|
TP_printk("ring %p, user_data 0x%llx, res %d, flags %x, "
|
|
"overflow_cqe %p",
|
|
__entry->ctx, __entry->user_data, __entry->res,
|
|
__entry->cflags, __entry->ocqe)
|
|
);
|
|
|
|
#endif /* _TRACE_IO_URING_H */
|
|
|
|
/* This part must be outside protection */
|
|
#include <trace/define_trace.h>
|