X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=include%2Fringbuffer%2Fconfig.h;h=4ce36d18c9fa4af35ec633208616239396cdb51d;hb=8a57ec025ffbe56153748fd69b60118862707182;hp=1b01935b3147affca70c5ccfa8a15d185dd54441;hpb=2459130397d7e7eecc44a5f06a39d65c78257eef;p=lttng-modules.git diff --git a/include/ringbuffer/config.h b/include/ringbuffer/config.h index 1b01935b..4ce36d18 100644 --- a/include/ringbuffer/config.h +++ b/include/ringbuffer/config.h @@ -13,13 +13,14 @@ #include #include -#include -#include +#include +#include struct lib_ring_buffer; struct channel; struct lib_ring_buffer_config; -struct lib_ring_buffer_ctx; +struct lttng_kernel_ring_buffer_ctx; +struct lttng_kernel_ring_buffer_ctx_private; /* * Ring buffer client callbacks. Only used by slow path, never on fast path. @@ -35,7 +36,7 @@ struct lib_ring_buffer_client_cb { size_t (*record_header_size) (const struct lib_ring_buffer_config *config, struct channel *chan, size_t offset, size_t *pre_header_padding, - struct lib_ring_buffer_ctx *ctx, + struct lttng_kernel_ring_buffer_ctx *ctx, void *client_ctx); /* Slow path only, at subbuffer switch */ @@ -101,7 +102,9 @@ struct lib_ring_buffer_client_cb { * * RING_BUFFER_WAKEUP_BY_WRITER directly wakes up readers when a subbuffer is * ready to read. Lower latencies before the reader is woken up. Mainly suitable - * for drivers. + * for drivers. Going through an "irq_work" allows triggering this type of wakeup + * even from NMI context: the wakeup will be slightly delayed until the next + * interrupts are handled. * * RING_BUFFER_WAKEUP_NONE does not perform any wakeup whatsoever. The client * has the responsibility to perform wakeups. @@ -142,9 +145,8 @@ struct lib_ring_buffer_config { enum { RING_BUFFER_WAKEUP_BY_TIMER, /* wake up performed by timer */ RING_BUFFER_WAKEUP_BY_WRITER, /* - * writer wakes up reader, - * not lock-free - * (takes spinlock). + * writer wakes up reader through + * irq_work. */ } wakeup; /* @@ -155,6 +157,40 @@ struct lib_ring_buffer_config { struct lib_ring_buffer_client_cb cb; }; +/* + * ring buffer private context + * + * Private context passed to lib_ring_buffer_reserve(), lib_ring_buffer_commit(), + * lib_ring_buffer_try_discard_reserve(), lib_ring_buffer_align_ctx() and + * lib_ring_buffer_write(). + * + * Get struct lttng_kernel_ring_buffer_ctx parent with container_of(). + */ + +struct lttng_kernel_ring_buffer_ctx_private { + /* input received by lib_ring_buffer_reserve(). */ + struct channel *chan; /* ring buffer channel */ + + /* output from lib_ring_buffer_reserve() */ + int reserve_cpu; /* processor id updated by the reserve */ + size_t slot_size; /* size of the reserved slot */ + unsigned long buf_offset; /* offset following the record header */ + unsigned long pre_offset; /* + * Initial offset position _before_ + * the record is written. Positioned + * prior to record header alignment + * padding. + */ + u64 tsc; /* time-stamp counter value */ + unsigned int rflags; /* reservation flags */ + + struct lib_ring_buffer *buf; /* + * buffer corresponding to processor id + * for this channel + */ + struct lib_ring_buffer_backend_pages *backend_pages; +}; + /* * ring buffer context * @@ -162,58 +198,38 @@ struct lib_ring_buffer_config { * lib_ring_buffer_try_discard_reserve(), lib_ring_buffer_align_ctx() and * lib_ring_buffer_write(). */ -struct lib_ring_buffer_ctx { +struct lttng_kernel_ring_buffer_ctx { + /* Private ring buffer context, set by reserve callback. */ + struct lttng_kernel_ring_buffer_ctx_private priv; + /* input received by lib_ring_buffer_reserve(), saved here. */ - struct channel *chan; /* channel */ - void *priv; /* client private data */ + void *client_priv; /* Ring buffer client private data */ + size_t data_size; /* size of payload */ int largest_align; /* * alignment of the largest element * in the payload */ - int cpu; /* processor id */ - - /* output from lib_ring_buffer_reserve() */ - struct lib_ring_buffer *buf; /* - * buffer corresponding to processor id - * for this channel - */ - size_t slot_size; /* size of the reserved slot */ - unsigned long buf_offset; /* offset following the record header */ - unsigned long pre_offset; /* - * Initial offset position _before_ - * the record is written. Positioned - * prior to record header alignment - * padding. - */ - u64 tsc; /* time-stamp counter value */ - unsigned int rflags; /* reservation flags */ - /* Cache backend pages pointer chasing. */ - struct lib_ring_buffer_backend_pages *backend_pages; + struct lttng_kernel_probe_ctx *probe_ctx; /* Probe context */ }; /** * lib_ring_buffer_ctx_init - initialize ring buffer context * @ctx: ring buffer context to initialize - * @chan: channel - * @priv: client private data + * @client_priv: client private data * @data_size: size of record data payload. It must be greater than 0. * @largest_align: largest alignment within data payload types - * @cpu: processor id */ static inline -void lib_ring_buffer_ctx_init(struct lib_ring_buffer_ctx *ctx, - struct channel *chan, void *priv, +void lib_ring_buffer_ctx_init(struct lttng_kernel_ring_buffer_ctx *ctx, + void *client_priv, size_t data_size, int largest_align, - int cpu) + struct lttng_kernel_probe_ctx *probe_ctx) { - ctx->chan = chan; - ctx->priv = priv; + ctx->client_priv = client_priv; ctx->data_size = data_size; ctx->largest_align = largest_align; - ctx->cpu = cpu; - ctx->rflags = 0; - ctx->backend_pages = NULL; + ctx->probe_ctx = probe_ctx; } /* @@ -234,7 +250,7 @@ void lib_ring_buffer_ctx_init(struct lib_ring_buffer_ctx *ctx, #define RING_BUFFER_RFLAG_END (1U << 1) #ifndef LTTNG_TRACER_CORE_H -#error "lttng-tracer-core.h is needed for RING_BUFFER_ALIGN define" +#error "lttng/tracer-core.h is needed for RING_BUFFER_ALIGN define" #endif /* @@ -278,10 +294,10 @@ unsigned int lib_ring_buffer_align(size_t align_drift, size_t size_of_type) * @ctx: ring buffer context. */ static inline -void lib_ring_buffer_align_ctx(struct lib_ring_buffer_ctx *ctx, +void lib_ring_buffer_align_ctx(struct lttng_kernel_ring_buffer_ctx *ctx, size_t alignment) { - ctx->buf_offset += lib_ring_buffer_align(ctx->buf_offset, + ctx->priv.buf_offset += lib_ring_buffer_align(ctx->priv.buf_offset, alignment); }