X-Git-Url: http://git.liburcu.org/?p=lttng-modules.git;a=blobdiff_plain;f=src%2Flttng-ring-buffer-client.h;h=fa0b8d4709d2e4122edd654c77770d4ed3d64bdb;hp=6055d66bc63ee1437b3d3d4fc8a45e520a7e65d0;hb=HEAD;hpb=437d5aa59380583ce1cd14d394a53b398be1275d diff --git a/src/lttng-ring-buffer-client.h b/src/lttng-ring-buffer-client.h index 6055d66b..a1753e98 100644 --- a/src/lttng-ring-buffer-client.h +++ b/src/lttng-ring-buffer-client.h @@ -13,11 +13,12 @@ #include /* for wrapper_vmalloc_sync_mappings() */ #include #include +#include #include #include #define LTTNG_COMPACT_EVENT_BITS 5 -#define LTTNG_COMPACT_TSC_BITS 27 +#define LTTNG_COMPACT_TIMESTAMP_BITS 27 static struct lttng_transport lttng_relay_transport; @@ -68,7 +69,7 @@ struct lttng_client_ctx { size_t event_context_len; }; -static inline notrace u64 lib_ring_buffer_clock_read(struct channel *chan) +static inline notrace u64 lib_ring_buffer_clock_read(struct lttng_kernel_ring_buffer_channel *chan) { return trace_clock_read64(); } @@ -88,7 +89,8 @@ size_t ctx_get_aligned_size(size_t offset, struct lttng_kernel_ctx *ctx, static inline void ctx_get_struct_size(struct lttng_kernel_ctx *ctx, size_t *ctx_len, - struct lttng_channel *chan, struct lib_ring_buffer_ctx *bufctx) + struct lttng_kernel_channel_buffer *lttng_chan, + struct lttng_kernel_ring_buffer_ctx *bufctx) { int i; size_t offset = 0; @@ -98,18 +100,15 @@ void ctx_get_struct_size(struct lttng_kernel_ctx *ctx, size_t *ctx_len, return; } for (i = 0; i < ctx->nr_fields; i++) { - if (ctx->fields[i].get_size) - offset += ctx->fields[i].get_size(offset); - if (ctx->fields[i].get_size_arg) - offset += ctx->fields[i].get_size_arg(offset, - &ctx->fields[i], bufctx, chan); + offset += ctx->fields[i].get_size(ctx->fields[i].priv, + bufctx->probe_ctx, offset); } *ctx_len = offset; } static inline -void ctx_record(struct lib_ring_buffer_ctx *bufctx, - struct lttng_channel *chan, +void ctx_record(struct lttng_kernel_ring_buffer_ctx *bufctx, + struct lttng_kernel_channel_buffer *lttng_chan, struct lttng_kernel_ctx *ctx) { int i; @@ -118,7 +117,8 @@ void ctx_record(struct lib_ring_buffer_ctx *bufctx, return; lib_ring_buffer_align_ctx(bufctx, ctx->largest_align); for (i = 0; i < ctx->nr_fields; i++) - ctx->fields[i].record(&ctx->fields[i], bufctx, chan); + ctx->fields[i].record(ctx->fields[i].priv, bufctx->probe_ctx, + bufctx, lttng_chan); } /* @@ -135,23 +135,21 @@ void ctx_record(struct lib_ring_buffer_ctx *bufctx, * contains. */ static __inline__ -size_t record_header_size(const struct lib_ring_buffer_config *config, - struct channel *chan, size_t offset, +size_t record_header_size(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer_channel *chan, size_t offset, size_t *pre_header_padding, - struct lib_ring_buffer_ctx *ctx, + struct lttng_kernel_ring_buffer_ctx *ctx, struct lttng_client_ctx *client_ctx) { - struct lttng_channel *lttng_chan = channel_get_private(chan); - struct lttng_probe_ctx *lttng_probe_ctx = ctx->priv; - struct lttng_event *event = lttng_probe_ctx->event; + struct lttng_kernel_channel_buffer *lttng_chan = channel_get_private(chan); size_t orig_offset = offset; size_t padding; - switch (lttng_chan->header_type) { + switch (lttng_chan->priv->header_type) { case 1: /* compact */ padding = lib_ring_buffer_align(offset, lttng_alignof(uint32_t)); offset += padding; - if (!(ctx->rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTTNG_RFLAG_EXTENDED))) { + if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TIMESTAMP | LTTNG_RFLAG_EXTENDED))) { offset += sizeof(uint32_t); /* id and timestamp */ } else { /* Minimum space taken by LTTNG_COMPACT_EVENT_BITS id */ @@ -167,7 +165,7 @@ size_t record_header_size(const struct lib_ring_buffer_config *config, padding = lib_ring_buffer_align(offset, lttng_alignof(uint16_t)); offset += padding; offset += sizeof(uint16_t); - if (!(ctx->rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTTNG_RFLAG_EXTENDED))) { + if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TIMESTAMP | LTTNG_RFLAG_EXTENDED))) { offset += lib_ring_buffer_align(offset, lttng_alignof(uint32_t)); offset += sizeof(uint32_t); /* timestamp */ } else { @@ -182,11 +180,8 @@ size_t record_header_size(const struct lib_ring_buffer_config *config, padding = 0; WARN_ON_ONCE(1); } - offset += ctx_get_aligned_size(offset, lttng_chan->ctx, + offset += ctx_get_aligned_size(offset, lttng_chan->priv->ctx, client_ctx->packet_context_len); - offset += ctx_get_aligned_size(offset, event->ctx, - client_ctx->event_context_len); - *pre_header_padding = padding; return offset - orig_offset; } @@ -194,8 +189,8 @@ size_t record_header_size(const struct lib_ring_buffer_config *config, #include static -void lttng_write_event_header_slow(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_ctx *ctx, +void lttng_write_event_header_slow(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer_ctx *ctx, uint32_t event_id); /* @@ -208,18 +203,16 @@ void lttng_write_event_header_slow(const struct lib_ring_buffer_config *config, * @event_id: event ID */ static __inline__ -void lttng_write_event_header(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_ctx *ctx, +void lttng_write_event_header(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer_ctx *ctx, uint32_t event_id) { - struct lttng_channel *lttng_chan = channel_get_private(ctx->chan); - struct lttng_probe_ctx *lttng_probe_ctx = ctx->priv; - struct lttng_event *event = lttng_probe_ctx->event; + struct lttng_kernel_channel_buffer *lttng_chan = channel_get_private(ctx->priv.chan); - if (unlikely(ctx->rflags)) + if (unlikely(ctx->priv.rflags)) goto slow_path; - switch (lttng_chan->header_type) { + switch (lttng_chan->priv->header_type) { case 1: /* compact */ { uint32_t id_time = 0; @@ -230,14 +223,14 @@ void lttng_write_event_header(const struct lib_ring_buffer_config *config, event_id); bt_bitfield_write(&id_time, uint32_t, LTTNG_COMPACT_EVENT_BITS, - LTTNG_COMPACT_TSC_BITS, - ctx->tsc); + LTTNG_COMPACT_TIMESTAMP_BITS, + ctx->priv.timestamp); lib_ring_buffer_write(config, ctx, &id_time, sizeof(id_time)); break; } case 2: /* large */ { - uint32_t timestamp = (uint32_t) ctx->tsc; + uint32_t timestamp = (uint32_t) ctx->priv.timestamp; uint16_t id = event_id; lib_ring_buffer_write(config, ctx, &id, sizeof(id)); @@ -249,8 +242,7 @@ void lttng_write_event_header(const struct lib_ring_buffer_config *config, WARN_ON_ONCE(1); } - ctx_record(ctx, lttng_chan, lttng_chan->ctx); - ctx_record(ctx, lttng_chan, event->ctx); + ctx_record(ctx, lttng_chan, lttng_chan->priv->ctx); lib_ring_buffer_align_ctx(ctx, ctx->largest_align); return; @@ -260,17 +252,15 @@ slow_path: } static -void lttng_write_event_header_slow(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_ctx *ctx, +void lttng_write_event_header_slow(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer_ctx *ctx, uint32_t event_id) { - struct lttng_channel *lttng_chan = channel_get_private(ctx->chan); - struct lttng_probe_ctx *lttng_probe_ctx = ctx->priv; - struct lttng_event *event = lttng_probe_ctx->event; + struct lttng_kernel_channel_buffer *lttng_chan = channel_get_private(ctx->priv.chan); - switch (lttng_chan->header_type) { + switch (lttng_chan->priv->header_type) { case 1: /* compact */ - if (!(ctx->rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTTNG_RFLAG_EXTENDED))) { + if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TIMESTAMP | LTTNG_RFLAG_EXTENDED))) { uint32_t id_time = 0; bt_bitfield_write(&id_time, uint32_t, @@ -279,11 +269,11 @@ void lttng_write_event_header_slow(const struct lib_ring_buffer_config *config, event_id); bt_bitfield_write(&id_time, uint32_t, LTTNG_COMPACT_EVENT_BITS, - LTTNG_COMPACT_TSC_BITS, ctx->tsc); + LTTNG_COMPACT_TIMESTAMP_BITS, ctx->priv.timestamp); lib_ring_buffer_write(config, ctx, &id_time, sizeof(id_time)); } else { uint8_t id = 0; - uint64_t timestamp = ctx->tsc; + uint64_t timestamp = ctx->priv.timestamp; bt_bitfield_write(&id, uint8_t, 0, @@ -299,8 +289,8 @@ void lttng_write_event_header_slow(const struct lib_ring_buffer_config *config, break; case 2: /* large */ { - if (!(ctx->rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTTNG_RFLAG_EXTENDED))) { - uint32_t timestamp = (uint32_t) ctx->tsc; + if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TIMESTAMP | LTTNG_RFLAG_EXTENDED))) { + uint32_t timestamp = (uint32_t) ctx->priv.timestamp; uint16_t id = event_id; lib_ring_buffer_write(config, ctx, &id, sizeof(id)); @@ -308,7 +298,7 @@ void lttng_write_event_header_slow(const struct lib_ring_buffer_config *config, lib_ring_buffer_write(config, ctx, ×tamp, sizeof(timestamp)); } else { uint16_t id = 65535; - uint64_t timestamp = ctx->tsc; + uint64_t timestamp = ctx->priv.timestamp; lib_ring_buffer_write(config, ctx, &id, sizeof(id)); /* Align extended struct on largest member */ @@ -322,23 +312,22 @@ void lttng_write_event_header_slow(const struct lib_ring_buffer_config *config, default: WARN_ON_ONCE(1); } - ctx_record(ctx, lttng_chan, lttng_chan->ctx); - ctx_record(ctx, lttng_chan, event->ctx); + ctx_record(ctx, lttng_chan, lttng_chan->priv->ctx); lib_ring_buffer_align_ctx(ctx, ctx->largest_align); } -static const struct lib_ring_buffer_config client_config; +static const struct lttng_kernel_ring_buffer_config client_config; -static u64 client_ring_buffer_clock_read(struct channel *chan) +static u64 client_ring_buffer_clock_read(struct lttng_kernel_ring_buffer_channel *chan) { return lib_ring_buffer_clock_read(chan); } static -size_t client_record_header_size(const struct lib_ring_buffer_config *config, - struct channel *chan, size_t offset, +size_t client_record_header_size(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer_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) { return record_header_size(config, chan, offset, @@ -357,22 +346,22 @@ static size_t client_packet_header_size(void) return offsetof(struct packet_header, ctx.header_end); } -static void client_buffer_begin(struct lib_ring_buffer *buf, u64 tsc, +static void client_buffer_begin(struct lttng_kernel_ring_buffer *buf, u64 timestamp, unsigned int subbuf_idx) { - struct channel *chan = buf->backend.chan; + struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan; struct packet_header *header = (struct packet_header *) lib_ring_buffer_offset_address(&buf->backend, subbuf_idx * chan->backend.subbuf_size); - struct lttng_channel *lttng_chan = channel_get_private(chan); - struct lttng_session *session = lttng_chan->session; + struct lttng_kernel_channel_buffer *lttng_chan = channel_get_private(chan); + struct lttng_kernel_session *session = lttng_chan->parent.session; header->magic = CTF_MAGIC_NUMBER; - memcpy(header->uuid, session->uuid.b, sizeof(session->uuid)); - header->stream_id = lttng_chan->id; + memcpy(header->uuid, session->priv->uuid.b, sizeof(session->priv->uuid)); + header->stream_id = lttng_chan->priv->id; header->stream_instance_id = buf->backend.cpu; - header->ctx.timestamp_begin = tsc; + header->ctx.timestamp_begin = timestamp; header->ctx.timestamp_end = 0; header->ctx.content_size = ~0ULL; /* for debugging */ header->ctx.packet_size = ~0ULL; @@ -387,46 +376,47 @@ static void client_buffer_begin(struct lib_ring_buffer *buf, u64 tsc, * offset is assumed to never be 0 here : never deliver a completely empty * subbuffer. data_size is between 1 and subbuf_size. */ -static void client_buffer_end(struct lib_ring_buffer *buf, u64 tsc, - unsigned int subbuf_idx, unsigned long data_size) +static void client_buffer_end(struct lttng_kernel_ring_buffer *buf, u64 timestamp, + unsigned int subbuf_idx, unsigned long data_size, + const struct lttng_kernel_ring_buffer_ctx *ctx) { - struct channel *chan = buf->backend.chan; + struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan; struct packet_header *header = (struct packet_header *) lib_ring_buffer_offset_address(&buf->backend, subbuf_idx * chan->backend.subbuf_size); unsigned long records_lost = 0; - header->ctx.timestamp_end = tsc; + header->ctx.timestamp_end = timestamp; header->ctx.content_size = (uint64_t) data_size * CHAR_BIT; /* in bits */ header->ctx.packet_size = (uint64_t) PAGE_ALIGN(data_size) * CHAR_BIT; /* in bits */ - records_lost += lib_ring_buffer_get_records_lost_full(&client_config, buf); - records_lost += lib_ring_buffer_get_records_lost_wrap(&client_config, buf); - records_lost += lib_ring_buffer_get_records_lost_big(&client_config, buf); + records_lost += lib_ring_buffer_get_records_lost_full(&client_config, ctx); + records_lost += lib_ring_buffer_get_records_lost_wrap(&client_config, ctx); + records_lost += lib_ring_buffer_get_records_lost_big(&client_config, ctx); header->ctx.events_discarded = records_lost; } -static int client_buffer_create(struct lib_ring_buffer *buf, void *priv, +static int client_buffer_create(struct lttng_kernel_ring_buffer *buf, void *priv, int cpu, const char *name) { return 0; } -static void client_buffer_finalize(struct lib_ring_buffer *buf, void *priv, int cpu) +static void client_buffer_finalize(struct lttng_kernel_ring_buffer *buf, void *priv, int cpu) { } static struct packet_header *client_packet_header( - const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf) + const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf) { return lib_ring_buffer_read_offset_address(&buf->backend, 0); } -static int client_timestamp_begin(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, +static int client_timestamp_begin(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf, uint64_t *timestamp_begin) { struct packet_header *header = client_packet_header(config, buf); @@ -435,8 +425,8 @@ static int client_timestamp_begin(const struct lib_ring_buffer_config *config, return 0; } -static int client_timestamp_end(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, +static int client_timestamp_end(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf, uint64_t *timestamp_end) { struct packet_header *header = client_packet_header(config, buf); @@ -445,8 +435,8 @@ static int client_timestamp_end(const struct lib_ring_buffer_config *config, return 0; } -static int client_events_discarded(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, +static int client_events_discarded(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf, uint64_t *events_discarded) { struct packet_header *header = client_packet_header(config, buf); @@ -455,8 +445,8 @@ static int client_events_discarded(const struct lib_ring_buffer_config *config, return 0; } -static int client_content_size(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, +static int client_content_size(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf, uint64_t *content_size) { struct packet_header *header = client_packet_header(config, buf); @@ -465,8 +455,8 @@ static int client_content_size(const struct lib_ring_buffer_config *config, return 0; } -static int client_packet_size(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, +static int client_packet_size(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf, uint64_t *packet_size) { struct packet_header *header = client_packet_header(config, buf); @@ -475,19 +465,19 @@ static int client_packet_size(const struct lib_ring_buffer_config *config, return 0; } -static int client_stream_id(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, +static int client_stream_id(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf, uint64_t *stream_id) { - struct channel *chan = buf->backend.chan; - struct lttng_channel *lttng_chan = channel_get_private(chan); + struct lttng_kernel_ring_buffer_channel *chan = buf->backend.chan; + struct lttng_kernel_channel_buffer *lttng_chan = channel_get_private(chan); - *stream_id = lttng_chan->id; + *stream_id = lttng_chan->priv->id; return 0; } -static int client_current_timestamp(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *bufb, +static int client_current_timestamp(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *bufb, uint64_t *ts) { *ts = config->cb.ring_buffer_clock_read(bufb->backend.chan); @@ -495,8 +485,8 @@ static int client_current_timestamp(const struct lib_ring_buffer_config *config, return 0; } -static int client_sequence_number(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, +static int client_sequence_number(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf, uint64_t *seq) { struct packet_header *header = client_packet_header(config, buf); @@ -507,8 +497,8 @@ static int client_sequence_number(const struct lib_ring_buffer_config *config, } static -int client_instance_id(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer *buf, +int client_instance_id(const struct lttng_kernel_ring_buffer_config *config, + struct lttng_kernel_ring_buffer *buf, uint64_t *id) { *id = buf->backend.cpu; @@ -516,7 +506,7 @@ int client_instance_id(const struct lib_ring_buffer_config *config, return 0; } -static const struct lib_ring_buffer_config client_config = { +static const struct lttng_kernel_ring_buffer_config client_config = { .cb.ring_buffer_clock_read = client_ring_buffer_clock_read, .cb.record_header_size = client_record_header_size, .cb.subbuffer_header_size = client_packet_header_size, @@ -525,7 +515,7 @@ static const struct lib_ring_buffer_config client_config = { .cb.buffer_create = client_buffer_create, .cb.buffer_finalize = client_buffer_finalize, - .tsc_bits = LTTNG_COMPACT_TSC_BITS, + .timestamp_bits = LTTNG_COMPACT_TIMESTAMP_BITS, .alloc = RING_BUFFER_ALLOC_PER_CPU, .sync = RING_BUFFER_SYNC_PER_CPU, .mode = RING_BUFFER_MODE_TEMPLATE, @@ -543,20 +533,20 @@ void release_priv_ops(void *priv_ops) } static -void lttng_channel_destroy(struct channel *chan) +void lttng_channel_destroy(struct lttng_kernel_ring_buffer_channel *chan) { channel_destroy(chan); } static -struct channel *_channel_create(const char *name, +struct lttng_kernel_ring_buffer_channel *_channel_create(const char *name, void *priv, void *buf_addr, size_t subbuf_size, size_t num_subbuf, unsigned int switch_timer_interval, unsigned int read_timer_interval) { - struct lttng_channel *lttng_chan = priv; - struct channel *chan; + struct lttng_kernel_channel_buffer *lttng_chan = priv; + struct lttng_kernel_ring_buffer_channel *chan; chan = channel_create(&client_config, name, lttng_chan, buf_addr, subbuf_size, num_subbuf, switch_timer_interval, @@ -581,9 +571,9 @@ error: } static -struct lib_ring_buffer *lttng_buffer_read_open(struct channel *chan) +struct lttng_kernel_ring_buffer *lttng_buffer_read_open(struct lttng_kernel_ring_buffer_channel *chan) { - struct lib_ring_buffer *buf; + struct lttng_kernel_ring_buffer *buf; int cpu; for_each_channel_cpu(cpu, chan) { @@ -595,9 +585,9 @@ struct lib_ring_buffer *lttng_buffer_read_open(struct channel *chan) } static -int lttng_buffer_has_read_closed_stream(struct channel *chan) +int lttng_buffer_has_read_closed_stream(struct lttng_kernel_ring_buffer_channel *chan) { - struct lib_ring_buffer *buf; + struct lttng_kernel_ring_buffer *buf; int cpu; for_each_channel_cpu(cpu, chan) { @@ -609,38 +599,39 @@ int lttng_buffer_has_read_closed_stream(struct channel *chan) } static -void lttng_buffer_read_close(struct lib_ring_buffer *buf) +void lttng_buffer_read_close(struct lttng_kernel_ring_buffer *buf) { lib_ring_buffer_release_read(buf); } static -int lttng_event_reserve(struct lib_ring_buffer_ctx *ctx, - uint32_t event_id) +int lttng_event_reserve(struct lttng_kernel_ring_buffer_ctx *ctx) { - struct lttng_channel *lttng_chan = channel_get_private(ctx->chan); - struct lttng_probe_ctx *lttng_probe_ctx = ctx->priv; - struct lttng_event *event = lttng_probe_ctx->event; + struct lttng_kernel_event_recorder *event_recorder = ctx->client_priv; + struct lttng_kernel_channel_buffer *lttng_chan = event_recorder->chan; struct lttng_client_ctx client_ctx; int ret, cpu; + uint32_t event_id; cpu = lib_ring_buffer_get_cpu(&client_config); if (unlikely(cpu < 0)) return -EPERM; - ctx->cpu = cpu; + event_id = event_recorder->priv->id; + memset(&ctx->priv, 0, sizeof(ctx->priv)); + ctx->priv.chan = lttng_chan->priv->rb_chan; + ctx->priv.reserve_cpu = cpu; /* Compute internal size of context structures. */ - ctx_get_struct_size(lttng_chan->ctx, &client_ctx.packet_context_len, lttng_chan, ctx); - ctx_get_struct_size(event->ctx, &client_ctx.event_context_len, lttng_chan, ctx); + ctx_get_struct_size(lttng_chan->priv->ctx, &client_ctx.packet_context_len, lttng_chan, ctx); - switch (lttng_chan->header_type) { + switch (lttng_chan->priv->header_type) { case 1: /* compact */ if (event_id > 30) - ctx->rflags |= LTTNG_RFLAG_EXTENDED; + ctx->priv.rflags |= LTTNG_RFLAG_EXTENDED; break; case 2: /* large */ if (event_id > 65534) - ctx->rflags |= LTTNG_RFLAG_EXTENDED; + ctx->priv.rflags |= LTTNG_RFLAG_EXTENDED; break; default: WARN_ON_ONCE(1); @@ -650,7 +641,7 @@ int lttng_event_reserve(struct lib_ring_buffer_ctx *ctx, if (unlikely(ret)) goto put; lib_ring_buffer_backend_get_pages(&client_config, ctx, - &ctx->backend_pages); + &ctx->priv.backend_pages); lttng_write_event_header(&client_config, ctx, event_id); return 0; put: @@ -659,42 +650,44 @@ put: } static -void lttng_event_commit(struct lib_ring_buffer_ctx *ctx) +void lttng_event_commit(struct lttng_kernel_ring_buffer_ctx *ctx) { lib_ring_buffer_commit(&client_config, ctx); lib_ring_buffer_put_cpu(&client_config); } static -void lttng_event_write(struct lib_ring_buffer_ctx *ctx, const void *src, - size_t len) +void lttng_event_write(struct lttng_kernel_ring_buffer_ctx *ctx, const void *src, + size_t len, size_t alignment) { + lib_ring_buffer_align_ctx(ctx, alignment); lib_ring_buffer_write(&client_config, ctx, src, len); } static -void lttng_event_write_from_user(struct lib_ring_buffer_ctx *ctx, - const void __user *src, size_t len) +void lttng_event_write_from_user(struct lttng_kernel_ring_buffer_ctx *ctx, + const void __user *src, size_t len, size_t alignment) { + lib_ring_buffer_align_ctx(ctx, alignment); lib_ring_buffer_copy_from_user_inatomic(&client_config, ctx, src, len); } static -void lttng_event_memset(struct lib_ring_buffer_ctx *ctx, +void lttng_event_memset(struct lttng_kernel_ring_buffer_ctx *ctx, int c, size_t len) { lib_ring_buffer_memset(&client_config, ctx, c, len); } static -void lttng_event_strcpy(struct lib_ring_buffer_ctx *ctx, const char *src, +void lttng_event_strcpy(struct lttng_kernel_ring_buffer_ctx *ctx, const char *src, size_t len) { lib_ring_buffer_strcpy(&client_config, ctx, src, len, '#'); } static -void lttng_event_strcpy_from_user(struct lib_ring_buffer_ctx *ctx, +void lttng_event_strcpy_from_user(struct lttng_kernel_ring_buffer_ctx *ctx, const char __user *src, size_t len) { lib_ring_buffer_strcpy_from_user_inatomic(&client_config, ctx, src, @@ -702,27 +695,47 @@ void lttng_event_strcpy_from_user(struct lib_ring_buffer_ctx *ctx, } static -wait_queue_head_t *lttng_get_writer_buf_wait_queue(struct channel *chan, int cpu) +void lttng_event_pstrcpy_pad(struct lttng_kernel_ring_buffer_ctx *ctx, const char *src, + size_t len) +{ + lib_ring_buffer_pstrcpy(&client_config, ctx, src, len, '\0'); +} + +static +void lttng_event_pstrcpy_pad_from_user(struct lttng_kernel_ring_buffer_ctx *ctx, const char __user *src, + size_t len) +{ + lib_ring_buffer_pstrcpy_from_user_inatomic(&client_config, ctx, src, len, '\0'); +} + +static +void lttng_channel_buffer_lost_event_too_big(struct lttng_kernel_channel_buffer *lttng_chan) +{ + lib_ring_buffer_lost_event_too_big(lttng_chan->priv->rb_chan); +} + +static +wait_queue_head_t *lttng_get_writer_buf_wait_queue(struct lttng_kernel_ring_buffer_channel *chan, int cpu) { - struct lib_ring_buffer *buf = channel_get_ring_buffer(&client_config, + struct lttng_kernel_ring_buffer *buf = channel_get_ring_buffer(&client_config, chan, cpu); return &buf->write_wait; } static -wait_queue_head_t *lttng_get_hp_wait_queue(struct channel *chan) +wait_queue_head_t *lttng_get_hp_wait_queue(struct lttng_kernel_ring_buffer_channel *chan) { return &chan->hp_wait; } static -int lttng_is_finalized(struct channel *chan) +int lttng_is_finalized(struct lttng_kernel_ring_buffer_channel *chan) { return lib_ring_buffer_channel_is_finalized(chan); } static -int lttng_is_disabled(struct channel *chan) +int lttng_is_disabled(struct lttng_kernel_ring_buffer_channel *chan) { return lib_ring_buffer_channel_is_disabled(chan); } @@ -731,12 +744,29 @@ static struct lttng_transport lttng_relay_transport = { .name = "relay-" RING_BUFFER_MODE_TEMPLATE_STRING, .owner = THIS_MODULE, .ops = { - .channel_create = _channel_create, - .channel_destroy = lttng_channel_destroy, - .buffer_read_open = lttng_buffer_read_open, - .buffer_has_read_closed_stream = - lttng_buffer_has_read_closed_stream, - .buffer_read_close = lttng_buffer_read_close, + .priv = __LTTNG_COMPOUND_LITERAL(struct lttng_kernel_channel_buffer_ops_private, { + .pub = <tng_relay_transport.ops, + .channel_create = _channel_create, + .channel_destroy = lttng_channel_destroy, + .buffer_read_open = lttng_buffer_read_open, + .buffer_has_read_closed_stream = + lttng_buffer_has_read_closed_stream, + .buffer_read_close = lttng_buffer_read_close, + .packet_avail_size = NULL, /* Would be racy anyway */ + .get_writer_buf_wait_queue = lttng_get_writer_buf_wait_queue, + .get_hp_wait_queue = lttng_get_hp_wait_queue, + .is_finalized = lttng_is_finalized, + .is_disabled = lttng_is_disabled, + .timestamp_begin = client_timestamp_begin, + .timestamp_end = client_timestamp_end, + .events_discarded = client_events_discarded, + .content_size = client_content_size, + .packet_size = client_packet_size, + .stream_id = client_stream_id, + .current_timestamp = client_current_timestamp, + .sequence_number = client_sequence_number, + .instance_id = client_instance_id, + }), .event_reserve = lttng_event_reserve, .event_commit = lttng_event_commit, .event_write = lttng_event_write, @@ -744,20 +774,9 @@ static struct lttng_transport lttng_relay_transport = { .event_memset = lttng_event_memset, .event_strcpy = lttng_event_strcpy, .event_strcpy_from_user = lttng_event_strcpy_from_user, - .packet_avail_size = NULL, /* Would be racy anyway */ - .get_writer_buf_wait_queue = lttng_get_writer_buf_wait_queue, - .get_hp_wait_queue = lttng_get_hp_wait_queue, - .is_finalized = lttng_is_finalized, - .is_disabled = lttng_is_disabled, - .timestamp_begin = client_timestamp_begin, - .timestamp_end = client_timestamp_end, - .events_discarded = client_events_discarded, - .content_size = client_content_size, - .packet_size = client_packet_size, - .stream_id = client_stream_id, - .current_timestamp = client_current_timestamp, - .sequence_number = client_sequence_number, - .instance_id = client_instance_id, + .event_pstrcpy_pad = lttng_event_pstrcpy_pad, + .event_pstrcpy_pad_from_user = lttng_event_pstrcpy_pad_from_user, + .lost_event_too_big = lttng_channel_buffer_lost_event_too_big, }, };