From 881833e349e275ac324fc3abf8a34d76f91047ea Mon Sep 17 00:00:00 2001 From: Mathieu Desnoyers Date: Wed, 11 May 2011 12:18:45 -0400 Subject: [PATCH] Add metadata transport Signed-off-by: Mathieu Desnoyers --- Makefile | 3 +- ltt-debugfs-abi.c | 8 +- ltt-event-header.c | 66 -------- ltt-ring-buffer-client.h | 180 +++++++++++++++++++++ ltt-ring-buffer-metadata-client.c | 20 +++ ltt-ring-buffer-metadata-client.h | 251 ++++++++++++++++++++++++++++++ ltt-tracer.h | 131 +--------------- 7 files changed, 455 insertions(+), 204 deletions(-) delete mode 100644 ltt-event-header.c create mode 100644 ltt-ring-buffer-metadata-client.c create mode 100644 ltt-ring-buffer-metadata-client.h diff --git a/Makefile b/Makefile index ac8618de..8da265d5 100644 --- a/Makefile +++ b/Makefile @@ -7,9 +7,10 @@ ifneq ($(CONFIG_TRACEPOINTS),) obj-m += ltt-ring-buffer-client-discard.o obj-m += ltt-ring-buffer-client-overwrite.o +obj-m += ltt-ring-buffer-metadata-client.o obj-m += ltt-relay.o -ltt-relay-objs := ltt-events.o ltt-event-header.o ltt-debugfs-abi.o \ +ltt-relay-objs := ltt-events.o ltt-debugfs-abi.o \ ltt-probes.o ltt-core.o obj-m += probes/ diff --git a/ltt-debugfs-abi.c b/ltt-debugfs-abi.c index afee47c9..99b41966 100644 --- a/ltt-debugfs-abi.c +++ b/ltt-debugfs-abi.c @@ -47,7 +47,6 @@ static const struct file_operations lttng_event_fops; enum channel_type { PER_CPU_CHANNEL, - GLOBAL_CHANNEL, METADATA_CHANNEL, }; @@ -187,13 +186,8 @@ int lttng_abi_create_channel(struct file *session_file, "relay-overwrite" : "relay-discard"; fops = <tng_channel_fops; break; - case GLOBAL_CHANNEL: - transport_name = chan_param.overwrite ? - "global-relay-overwrite" : "global-relay-discard"; - fops = <tng_channel_fops; - break; case METADATA_CHANNEL: - transport_name = "global-relay-discard"; + transport_name = "relay-metadata"; fops = <tng_metadata_fops; break; default: diff --git a/ltt-event-header.c b/ltt-event-header.c deleted file mode 100644 index dc8bb997..00000000 --- a/ltt-event-header.c +++ /dev/null @@ -1,66 +0,0 @@ -/* - * ltt/ltt-event-header.c - * - * (C) Copyright 2010 - Mathieu Desnoyers (mathieu.desnoyers@efficios.com) - * - * LTTng event header. - * - * Author: - * Mathieu Desnoyers (mathieu.desnoyers@efficios.com) - * - * Dual LGPL v2.1/GPL v2 license. - */ - -#include -#include "ltt-tracer.h" - -void ltt_write_event_header_slow(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_ctx *ctx, - u16 eID, u32 event_size) -{ - struct event_header header; - u16 small_size; - - switch (ctx->rflags) { - case LTT_RFLAG_ID_SIZE_TSC: - header.id_time = 29 << LTT_TSC_BITS; - break; - case LTT_RFLAG_ID_SIZE: - header.id_time = 30 << LTT_TSC_BITS; - break; - case LTT_RFLAG_ID: - header.id_time = 31 << LTT_TSC_BITS; - break; - default: - WARN_ON_ONCE(1); - header.id_time = 0; - } - - header.id_time |= (u32)ctx->tsc & LTT_TSC_MASK; - lib_ring_buffer_write(config, ctx, &header, sizeof(header)); - - switch (ctx->rflags) { - case LTT_RFLAG_ID_SIZE_TSC: - small_size = (u16)min_t(u32, event_size, LTT_MAX_SMALL_SIZE); - lib_ring_buffer_write(config, ctx, &eID, sizeof(u16)); - lib_ring_buffer_write(config, ctx, &small_size, sizeof(u16)); - if (small_size == LTT_MAX_SMALL_SIZE) - lib_ring_buffer_write(config, ctx, &event_size, - sizeof(u32)); - lib_ring_buffer_align_ctx(ctx, sizeof(u64)); - lib_ring_buffer_write(config, ctx, &ctx->tsc, sizeof(u64)); - break; - case LTT_RFLAG_ID_SIZE: - small_size = (u16)min_t(u32, event_size, LTT_MAX_SMALL_SIZE); - lib_ring_buffer_write(config, ctx, &eID, sizeof(u16)); - lib_ring_buffer_write(config, ctx, &small_size, sizeof(u16)); - if (small_size == LTT_MAX_SMALL_SIZE) - lib_ring_buffer_write(config, ctx, &event_size, - sizeof(u32)); - break; - case LTT_RFLAG_ID: - lib_ring_buffer_write(config, ctx, &eID, sizeof(u16)); - break; - } -} -EXPORT_SYMBOL_GPL(ltt_write_event_header_slow); diff --git a/ltt-ring-buffer-client.h b/ltt-ring-buffer-client.h index 219f69be..55d972ac 100644 --- a/ltt-ring-buffer-client.h +++ b/ltt-ring-buffer-client.h @@ -15,6 +15,186 @@ #include "ltt-events.h" #include "ltt-tracer.h" +static inline notrace u64 lib_ring_buffer_clock_read(struct channel *chan) +{ + return trace_clock_read64(); +} + +/* + * record_header_size - Calculate the header size and padding necessary. + * @config: ring buffer instance configuration + * @chan: channel + * @offset: offset in the write buffer + * @data_size: size of the payload + * @pre_header_padding: padding to add before the header (output) + * @rflags: reservation flags + * @ctx: reservation context + * + * Returns the event header size (including padding). + * + * Important note : + * The event header must be 32-bits. The total offset calculated here : + * + * Alignment of header struct on 32 bits (min arch size, header size) + * + sizeof(header struct) (32-bits) + * + (opt) u16 (ext. event id) + * + (opt) u16 (event_size) + * (if event_size == LTT_MAX_SMALL_SIZE, has ext. event size) + * + (opt) u32 (ext. event size) + * + (opt) u64 full TSC (aligned on min(64-bits, arch size)) + * + * The payload must itself determine its own alignment from the biggest type it + * contains. + */ +static __inline__ +unsigned char record_header_size(const struct lib_ring_buffer_config *config, + struct channel *chan, size_t offset, + size_t data_size, size_t *pre_header_padding, + unsigned int rflags, + struct lib_ring_buffer_ctx *ctx) +{ + size_t orig_offset = offset; + size_t padding; + + BUILD_BUG_ON(sizeof(struct event_header) != sizeof(u32)); + + padding = lib_ring_buffer_align(offset, + sizeof(struct event_header)); + offset += padding; + offset += sizeof(struct event_header); + + if (unlikely(rflags)) { + switch (rflags) { + case LTT_RFLAG_ID_SIZE_TSC: + offset += sizeof(u16) + sizeof(u16); + if (data_size >= LTT_MAX_SMALL_SIZE) + offset += sizeof(u32); + offset += lib_ring_buffer_align(offset, sizeof(u64)); + offset += sizeof(u64); + break; + case LTT_RFLAG_ID_SIZE: + offset += sizeof(u16) + sizeof(u16); + if (data_size >= LTT_MAX_SMALL_SIZE) + offset += sizeof(u32); + break; + case LTT_RFLAG_ID: + offset += sizeof(u16); + break; + } + } + + *pre_header_padding = padding; + return offset - orig_offset; +} + +#include "wrapper/ringbuffer/api.h" + +extern +void ltt_write_event_header_slow(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_ctx *ctx, + u16 eID, u32 event_size); + +/* + * ltt_write_event_header + * + * Writes the event header to the offset (already aligned on 32-bits). + * + * @config: ring buffer instance configuration + * @ctx: reservation context + * @eID : event ID + * @event_size : size of the event, excluding the event header. + */ +static __inline__ +void ltt_write_event_header(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_ctx *ctx, + u16 eID, u32 event_size) +{ + struct event_header header; + + if (unlikely(ctx->rflags)) + goto slow_path; + + header.id_time = eID << LTT_TSC_BITS; + header.id_time |= (u32)ctx->tsc & LTT_TSC_MASK; + lib_ring_buffer_write(config, ctx, &header, sizeof(header)); + +slow_path: + ltt_write_event_header_slow(config, ctx, eID, event_size); +} + +/** + * ltt_write_trace_header - Write trace header + * @priv: Private data (struct trace) + * @header: Memory address where the information must be written to + */ +static __inline__ +void write_trace_header(const struct lib_ring_buffer_config *config, + struct packet_header *header) +{ + header->magic = CTF_MAGIC_NUMBER; +#if 0 + /* TODO: move start time to metadata */ + header->major_version = LTT_TRACER_VERSION_MAJOR; + header->minor_version = LTT_TRACER_VERSION_MINOR; + header->arch_size = sizeof(void *); + header->alignment = lib_ring_buffer_get_alignment(config); + header->start_time_sec = ltt_chan->session->start_time.tv_sec; + header->start_time_usec = ltt_chan->session->start_time.tv_usec; + header->start_freq = ltt_chan->session->start_freq; + header->freq_scale = ltt_chan->session->freq_scale; +#endif //0 +} + +void ltt_write_event_header_slow(const struct lib_ring_buffer_config *config, + struct lib_ring_buffer_ctx *ctx, + u16 eID, u32 event_size) +{ + struct event_header header; + u16 small_size; + + switch (ctx->rflags) { + case LTT_RFLAG_ID_SIZE_TSC: + header.id_time = 29 << LTT_TSC_BITS; + break; + case LTT_RFLAG_ID_SIZE: + header.id_time = 30 << LTT_TSC_BITS; + break; + case LTT_RFLAG_ID: + header.id_time = 31 << LTT_TSC_BITS; + break; + default: + WARN_ON_ONCE(1); + header.id_time = 0; + } + + header.id_time |= (u32)ctx->tsc & LTT_TSC_MASK; + lib_ring_buffer_write(config, ctx, &header, sizeof(header)); + + switch (ctx->rflags) { + case LTT_RFLAG_ID_SIZE_TSC: + small_size = (u16)min_t(u32, event_size, LTT_MAX_SMALL_SIZE); + lib_ring_buffer_write(config, ctx, &eID, sizeof(u16)); + lib_ring_buffer_write(config, ctx, &small_size, sizeof(u16)); + if (small_size == LTT_MAX_SMALL_SIZE) + lib_ring_buffer_write(config, ctx, &event_size, + sizeof(u32)); + lib_ring_buffer_align_ctx(ctx, sizeof(u64)); + lib_ring_buffer_write(config, ctx, &ctx->tsc, sizeof(u64)); + break; + case LTT_RFLAG_ID_SIZE: + small_size = (u16)min_t(u32, event_size, LTT_MAX_SMALL_SIZE); + lib_ring_buffer_write(config, ctx, &eID, sizeof(u16)); + lib_ring_buffer_write(config, ctx, &small_size, sizeof(u16)); + if (small_size == LTT_MAX_SMALL_SIZE) + lib_ring_buffer_write(config, ctx, &event_size, + sizeof(u32)); + break; + case LTT_RFLAG_ID: + lib_ring_buffer_write(config, ctx, &eID, sizeof(u16)); + break; + } +} + static const struct lib_ring_buffer_config client_config; static u64 client_ring_buffer_clock_read(struct channel *chan) diff --git a/ltt-ring-buffer-metadata-client.c b/ltt-ring-buffer-metadata-client.c new file mode 100644 index 00000000..64f44085 --- /dev/null +++ b/ltt-ring-buffer-metadata-client.c @@ -0,0 +1,20 @@ +/* + * ltt-ring-buffer-metadata-client.c + * + * Copyright (C) 2010 - Mathieu Desnoyers + * + * LTTng lib ring buffer metadta client. + * + * Dual LGPL v2.1/GPL v2 license. + */ + +#include +#include "ltt-tracer.h" + +#define RING_BUFFER_MODE_TEMPLATE RING_BUFFER_DISCARD +#define RING_BUFFER_MODE_TEMPLATE_STRING "metadata" +#include "ltt-ring-buffer-metadata-client.h" + +MODULE_LICENSE("GPL and additional rights"); +MODULE_AUTHOR("Mathieu Desnoyers"); +MODULE_DESCRIPTION("LTTng Ring Buffer Metadata Client"); diff --git a/ltt-ring-buffer-metadata-client.h b/ltt-ring-buffer-metadata-client.h new file mode 100644 index 00000000..830e7990 --- /dev/null +++ b/ltt-ring-buffer-metadata-client.h @@ -0,0 +1,251 @@ +/* + * ltt-ring-buffer-client.h + * + * Copyright (C) 2010 - Mathieu Desnoyers + * + * LTTng lib ring buffer client template. + * + * Dual LGPL v2.1/GPL v2 license. + */ + +#include +#include +#include "wrapper/vmalloc.h" /* for wrapper_vmalloc_sync_all() */ +#include "ltt-events.h" +#include "ltt-tracer.h" + +#ifndef CHAR_BIT +#define CHAR_BIT 8 +#endif + +struct metadata_packet_header { + uint32_t magic; /* 0x75D11D57 */ + uint8_t trace_uuid[16]; /* Unique Universal Identifier */ + uint32_t checksum; /* 0 if unused */ + uint32_t content_size; /* in bits */ + uint32_t packet_size; /* in bits */ + uint8_t compression_scheme; /* 0 if unused */ + uint8_t encryption_scheme; /* 0 if unused */ + uint8_t checksum_scheme; /* 0 if unused */ + uint8_t header_end[0]; +}; + +struct metadata_record_header { + uint8_t header_end[0]; /* End of header */ +}; + +static const struct lib_ring_buffer_config client_config; + +static inline +u64 lib_ring_buffer_clock_read(struct channel *chan) +{ + return 0; +} + +static inline +unsigned char record_header_size(const struct lib_ring_buffer_config *config, + struct channel *chan, size_t offset, + size_t data_size, size_t *pre_header_padding, + unsigned int rflags, + struct lib_ring_buffer_ctx *ctx) +{ + return 0; +} + +#include "wrapper/ringbuffer/api.h" + +static u64 client_ring_buffer_clock_read(struct channel *chan) +{ + return 0; +} + +static +size_t client_record_header_size(const struct lib_ring_buffer_config *config, + struct channel *chan, size_t offset, + size_t data_size, + size_t *pre_header_padding, + unsigned int rflags, + struct lib_ring_buffer_ctx *ctx) +{ + return 0; +} + +/** + * client_packet_header_size - called on buffer-switch to a new sub-buffer + * + * Return header size without padding after the structure. Don't use packed + * structure because gcc generates inefficient code on some architectures + * (powerpc, mips..) + */ +static size_t client_packet_header_size(void) +{ + return offsetof(struct metadata_packet_header, header_end); +} + +static void client_buffer_begin(struct lib_ring_buffer *buf, u64 tsc, + unsigned int subbuf_idx) +{ + struct channel *chan = buf->backend.chan; + struct metadata_packet_header *header = + (struct metadata_packet_header *) + lib_ring_buffer_offset_address(&buf->backend, + subbuf_idx * chan->backend.subbuf_size); + + header->magic = TSDL_MAGIC_NUMBER; + /* TODO */ + //header->trace_uuid = ; /* Unique Universal Identifier */ + header->checksum = 0; /* 0 if unused */ + header->content_size = 0xFFFFFFFF; /* in bits, for debugging */ + header->packet_size = 0xFFFFFFFF; /* in bits, for debugging */ + header->compression_scheme = 0; /* 0 if unused */ + header->encryption_scheme = 0; /* 0 if unused */ + header->checksum_scheme = 0; /* 0 if unused */ +} + +/* + * 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) +{ + struct 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->content_size = data_size * CHAR_BIT; /* in bits */ + header->packet_size = 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); + WARN_ON_ONCE(records_lost != 0); +} + +static int client_buffer_create(struct lib_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 const struct lib_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, + .cb.buffer_begin = client_buffer_begin, + .cb.buffer_end = client_buffer_end, + .cb.buffer_create = client_buffer_create, + .cb.buffer_finalize = client_buffer_finalize, + + .tsc_bits = 0, + .alloc = RING_BUFFER_ALLOC_GLOBAL, + .sync = RING_BUFFER_SYNC_GLOBAL, + .mode = RING_BUFFER_MODE_TEMPLATE, + .backend = RING_BUFFER_PAGE, + .output = RING_BUFFER_SPLICE, + .oops = RING_BUFFER_OOPS_CONSISTENCY, + .ipi = RING_BUFFER_IPI_BARRIER, + .wakeup = RING_BUFFER_WAKEUP_BY_TIMER, +}; + +static +struct channel *_channel_create(const char *name, + struct ltt_session *session, void *buf_addr, + size_t subbuf_size, size_t num_subbuf, + unsigned int switch_timer_interval, + unsigned int read_timer_interval) +{ + return channel_create(&client_config, name, session, buf_addr, + subbuf_size, num_subbuf, switch_timer_interval, + read_timer_interval); +} + +static +void ltt_channel_destroy(struct channel *chan) +{ + channel_destroy(chan); +} + +static +struct lib_ring_buffer *ltt_buffer_read_open(struct channel *chan) +{ + struct lib_ring_buffer *buf; + int cpu; + + for_each_channel_cpu(cpu, chan) { + buf = channel_get_ring_buffer(&client_config, chan, cpu); + if (!lib_ring_buffer_open_read(buf)) + return buf; + } + return NULL; +} + +static +void ltt_buffer_read_close(struct lib_ring_buffer *buf) +{ + lib_ring_buffer_release_read(buf); + +} + +int ltt_event_reserve(struct lib_ring_buffer_ctx *ctx) +{ + return lib_ring_buffer_reserve(&client_config, ctx); +} + +void ltt_event_commit(struct lib_ring_buffer_ctx *ctx) +{ + lib_ring_buffer_commit(&client_config, ctx); +} + +void ltt_event_write(struct lib_ring_buffer_ctx *ctx, const void *src, + size_t len) +{ + lib_ring_buffer_write(&client_config, ctx, src, len); +} + +static struct ltt_transport ltt_relay_transport = { + .name = "relay-" RING_BUFFER_MODE_TEMPLATE_STRING, + .owner = THIS_MODULE, + .ops = { + .channel_create = _channel_create, + .channel_destroy = ltt_channel_destroy, + .buffer_read_open = ltt_buffer_read_open, + .buffer_read_close = ltt_buffer_read_close, + .event_reserve = ltt_event_reserve, + .event_commit = ltt_event_commit, + .event_write = ltt_event_write, + }, +}; + +static int __init ltt_ring_buffer_client_init(void) +{ + /* + * This vmalloc sync all also takes care of the lib ring buffer + * vmalloc'd module pages when it is built as a module into LTTng. + */ + wrapper_vmalloc_sync_all(); + printk(KERN_INFO "LTT : ltt ring buffer metadata client init\n"); + ltt_transport_register(<t_relay_transport); + return 0; +} + +module_init(ltt_ring_buffer_client_init); + +static void __exit ltt_ring_buffer_client_exit(void) +{ + printk(KERN_INFO "LTT : ltt ring buffer metadata client exit\n"); + ltt_transport_unregister(<t_relay_transport); +} + +module_exit(ltt_ring_buffer_client_exit); + +MODULE_LICENSE("GPL and additional rights"); +MODULE_AUTHOR("Mathieu Desnoyers"); +MODULE_DESCRIPTION("LTTng ring buffer " RING_BUFFER_MODE_TEMPLATE_STRING + " client"); diff --git a/ltt-tracer.h b/ltt-tracer.h index f4d1ef84..1540a28a 100644 --- a/ltt-tracer.h +++ b/ltt-tracer.h @@ -154,141 +154,12 @@ struct packet_header { uint8_t header_end[0]; /* End of header */ }; -static inline notrace u64 lib_ring_buffer_clock_read(struct channel *chan) -{ - return trace_clock_read64(); -} - -/* - * record_header_size - Calculate the header size and padding necessary. - * @config: ring buffer instance configuration - * @chan: channel - * @offset: offset in the write buffer - * @data_size: size of the payload - * @pre_header_padding: padding to add before the header (output) - * @rflags: reservation flags - * @ctx: reservation context - * - * Returns the event header size (including padding). - * - * Important note : - * The event header must be 32-bits. The total offset calculated here : - * - * Alignment of header struct on 32 bits (min arch size, header size) - * + sizeof(header struct) (32-bits) - * + (opt) u16 (ext. event id) - * + (opt) u16 (event_size) - * (if event_size == LTT_MAX_SMALL_SIZE, has ext. event size) - * + (opt) u32 (ext. event size) - * + (opt) u64 full TSC (aligned on min(64-bits, arch size)) - * - * The payload must itself determine its own alignment from the biggest type it - * contains. - */ -static __inline__ -unsigned char record_header_size(const struct lib_ring_buffer_config *config, - struct channel *chan, size_t offset, - size_t data_size, size_t *pre_header_padding, - unsigned int rflags, - struct lib_ring_buffer_ctx *ctx) -{ - size_t orig_offset = offset; - size_t padding; - - BUILD_BUG_ON(sizeof(struct event_header) != sizeof(u32)); - - padding = lib_ring_buffer_align(offset, - sizeof(struct event_header)); - offset += padding; - offset += sizeof(struct event_header); - - if (unlikely(rflags)) { - switch (rflags) { - case LTT_RFLAG_ID_SIZE_TSC: - offset += sizeof(u16) + sizeof(u16); - if (data_size >= LTT_MAX_SMALL_SIZE) - offset += sizeof(u32); - offset += lib_ring_buffer_align(offset, sizeof(u64)); - offset += sizeof(u64); - break; - case LTT_RFLAG_ID_SIZE: - offset += sizeof(u16) + sizeof(u16); - if (data_size >= LTT_MAX_SMALL_SIZE) - offset += sizeof(u32); - break; - case LTT_RFLAG_ID: - offset += sizeof(u16); - break; - } - } - - *pre_header_padding = padding; - return offset - orig_offset; -} - -#include "wrapper/ringbuffer/api.h" - -extern -void ltt_write_event_header_slow(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_ctx *ctx, - u16 eID, u32 event_size); - -/* - * ltt_write_event_header - * - * Writes the event header to the offset (already aligned on 32-bits). - * - * @config: ring buffer instance configuration - * @ctx: reservation context - * @eID : event ID - * @event_size : size of the event, excluding the event header. - */ -static __inline__ -void ltt_write_event_header(const struct lib_ring_buffer_config *config, - struct lib_ring_buffer_ctx *ctx, - u16 eID, u32 event_size) -{ - struct event_header header; - - if (unlikely(ctx->rflags)) - goto slow_path; - - header.id_time = eID << LTT_TSC_BITS; - header.id_time |= (u32)ctx->tsc & LTT_TSC_MASK; - lib_ring_buffer_write(config, ctx, &header, sizeof(header)); - -slow_path: - ltt_write_event_header_slow(config, ctx, eID, event_size); -} - /* Tracer properties */ #define CTF_MAGIC_NUMBER 0xC1FC1FC1 +#define TSDL_MAGIC_NUMBER 0x75D11D57 #define LTT_TRACER_VERSION_MAJOR 3 #define LTT_TRACER_VERSION_MINOR 0 -/** - * ltt_write_trace_header - Write trace header - * @priv: Private data (struct trace) - * @header: Memory address where the information must be written to - */ -static __inline__ -void write_trace_header(const struct lib_ring_buffer_config *config, - struct packet_header *header) -{ - header->magic = CTF_MAGIC_NUMBER; -#if 0 - /* TODO: move start time to metadata */ - header->major_version = LTT_TRACER_VERSION_MAJOR; - header->minor_version = LTT_TRACER_VERSION_MINOR; - header->arch_size = sizeof(void *); - header->alignment = lib_ring_buffer_get_alignment(config); - header->start_time_sec = ltt_chan->session->start_time.tv_sec; - header->start_time_usec = ltt_chan->session->start_time.tv_usec; - header->start_freq = ltt_chan->session->start_freq; - header->freq_scale = ltt_chan->session->freq_scale; -#endif //0 -} - /* * Size reserved for high priority events (interrupts, NMI, BH) at the end of a * nearly full buffer. User space won't use this last amount of space when in -- 2.34.1