#include <wrapper/vmalloc.h> /* for wrapper_vmalloc_sync_mappings() */
#include <wrapper/trace-clock.h>
#include <lttng/events.h>
+#include <lttng/events-internal.h>
#include <lttng/tracer.h>
#include <ringbuffer/frontend_types.h>
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_channel *chan, struct lttng_kernel_ring_buffer_ctx *bufctx)
{
int i;
size_t offset = 0;
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,
+void ctx_record(struct lttng_kernel_ring_buffer_ctx *bufctx,
struct lttng_channel *chan,
struct lttng_kernel_ctx *ctx)
{
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, chan);
}
/*
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,
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;
size_t orig_offset = offset;
size_t padding;
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_TSC | LTTNG_RFLAG_EXTENDED))) {
offset += sizeof(uint32_t); /* id and timestamp */
} else {
/* Minimum space taken by LTTNG_COMPACT_EVENT_BITS id */
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_TSC | LTTNG_RFLAG_EXTENDED))) {
offset += lib_ring_buffer_align(offset, lttng_alignof(uint32_t));
offset += sizeof(uint32_t); /* timestamp */
} else {
}
offset += ctx_get_aligned_size(offset, lttng_chan->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;
}
static
void lttng_write_event_header_slow(const struct lib_ring_buffer_config *config,
- struct lib_ring_buffer_ctx *ctx,
+ struct lttng_kernel_ring_buffer_ctx *ctx,
uint32_t event_id);
/*
*/
static __inline__
void lttng_write_event_header(const struct lib_ring_buffer_config *config,
- struct lib_ring_buffer_ctx *ctx,
+ 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_channel *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) {
bt_bitfield_write(&id_time, uint32_t,
LTTNG_COMPACT_EVENT_BITS,
LTTNG_COMPACT_TSC_BITS,
- ctx->tsc);
+ ctx->priv.tsc);
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.tsc;
uint16_t id = event_id;
lib_ring_buffer_write(config, ctx, &id, sizeof(id));
}
ctx_record(ctx, lttng_chan, lttng_chan->ctx);
- ctx_record(ctx, lttng_chan, event->ctx);
lib_ring_buffer_align_ctx(ctx, ctx->largest_align);
return;
static
void lttng_write_event_header_slow(const struct lib_ring_buffer_config *config,
- struct lib_ring_buffer_ctx *ctx,
+ 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_channel *lttng_chan = channel_get_private(ctx->priv.chan);
switch (lttng_chan->header_type) {
case 1: /* compact */
- if (!(ctx->rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTTNG_RFLAG_EXTENDED))) {
+ if (!(ctx->priv.rflags & (RING_BUFFER_RFLAG_FULL_TSC | LTTNG_RFLAG_EXTENDED))) {
uint32_t id_time = 0;
bt_bitfield_write(&id_time, uint32_t,
event_id);
bt_bitfield_write(&id_time, uint32_t,
LTTNG_COMPACT_EVENT_BITS,
- LTTNG_COMPACT_TSC_BITS, ctx->tsc);
+ LTTNG_COMPACT_TSC_BITS, ctx->priv.tsc);
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.tsc;
bt_bitfield_write(&id, uint8_t,
0,
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_TSC | LTTNG_RFLAG_EXTENDED))) {
+ uint32_t timestamp = (uint32_t) ctx->priv.tsc;
uint16_t id = event_id;
lib_ring_buffer_write(config, ctx, &id, sizeof(id));
lib_ring_buffer_write(config, ctx, ×tamp, sizeof(timestamp));
} else {
uint16_t id = 65535;
- uint64_t timestamp = ctx->tsc;
+ uint64_t timestamp = ctx->priv.tsc;
lib_ring_buffer_write(config, ctx, &id, sizeof(id));
/* Align extended struct on largest member */
WARN_ON_ONCE(1);
}
ctx_record(ctx, lttng_chan, lttng_chan->ctx);
- ctx_record(ctx, lttng_chan, event->ctx);
lib_ring_buffer_align_ctx(ctx, ctx->largest_align);
}
size_t client_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)
{
return record_header_size(config, chan, offset,
}
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_channel *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->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);
switch (lttng_chan->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);
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:
}
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,
+void lttng_event_write(struct lttng_kernel_ring_buffer_ctx *ctx, const void *src,
size_t len)
{
lib_ring_buffer_write(&client_config, ctx, src, len);
}
static
-void lttng_event_write_from_user(struct lib_ring_buffer_ctx *ctx,
+void lttng_event_write_from_user(struct lttng_kernel_ring_buffer_ctx *ctx,
const void __user *src, size_t len)
{
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,
.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,
.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,
},
};
projects / lttng-modules.git / blobdiff