X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=ltt-ring-buffer-metadata-client.h;h=529bbb19ffe72dce2897167b18bfaa781945e516;hb=9d7d747f10bab16b3d85915a5b87e10acd2374f0;hp=a0f6f9e12f2c45c75e6d13db2b9cc0db5dc4cf2f;hpb=cd4bd11fe2d3232089186a5b9b021b7cb504a8fb;p=lttng-modules.git diff --git a/ltt-ring-buffer-metadata-client.h b/ltt-ring-buffer-metadata-client.h index a0f6f9e1..529bbb19 100644 --- a/ltt-ring-buffer-metadata-client.h +++ b/ltt-ring-buffer-metadata-client.h @@ -16,13 +16,15 @@ struct metadata_packet_header { uint32_t magic; /* 0x75D11D57 */ - uint8_t trace_uuid[16]; /* Unique Universal Identifier */ + uint8_t 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 major; /* CTF spec major version number */ + uint8_t minor; /* CTF spec minor version number */ uint8_t header_end[0]; }; @@ -41,8 +43,7 @@ u64 lib_ring_buffer_clock_read(struct channel *chan) 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, + size_t *pre_header_padding, struct lib_ring_buffer_ctx *ctx) { return 0; @@ -58,9 +59,7 @@ static u64 client_ring_buffer_clock_read(struct channel *chan) 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; @@ -86,16 +85,19 @@ static void client_buffer_begin(struct lib_ring_buffer *buf, u64 tsc, (struct metadata_packet_header *) lib_ring_buffer_offset_address(&buf->backend, subbuf_idx * chan->backend.subbuf_size); + struct ltt_channel *ltt_chan = channel_get_private(chan); + struct ltt_session *session = ltt_chan->session; header->magic = TSDL_MAGIC_NUMBER; - /* TODO */ - //header->trace_uuid = ; /* Unique Universal Identifier */ + memcpy(header->uuid, session->uuid.b, sizeof(session->uuid)); 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 */ + header->major = CTF_SPEC_MAJOR; + header->minor = CTF_SPEC_MINOR; } /* @@ -106,15 +108,19 @@ 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 *) + struct metadata_packet_header *header = + (struct metadata_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); + /* + * We do not care about the records lost count, because the metadata + * channel waits and retry. + */ + (void) 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); @@ -144,7 +150,7 @@ static const struct lib_ring_buffer_config client_config = { .sync = RING_BUFFER_SYNC_GLOBAL, .mode = RING_BUFFER_MODE_TEMPLATE, .backend = RING_BUFFER_PAGE, - .output = RING_BUFFER_SPLICE, + .output = RING_BUFFER_OUTPUT_TEMPLATE, .oops = RING_BUFFER_OOPS_CONSISTENCY, .ipi = RING_BUFFER_IPI_BARRIER, .wakeup = RING_BUFFER_WAKEUP_BY_TIMER, @@ -152,12 +158,12 @@ static const struct lib_ring_buffer_config client_config = { static struct channel *_channel_create(const char *name, - struct ltt_session *session, void *buf_addr, + struct ltt_channel *ltt_chan, 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, + return channel_create(&client_config, name, ltt_chan, buf_addr, subbuf_size, num_subbuf, switch_timer_interval, read_timer_interval); } @@ -179,6 +185,20 @@ struct lib_ring_buffer *ltt_buffer_read_open(struct channel *chan) return NULL; } +static +int ltt_buffer_has_read_closed_stream(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 (!atomic_long_read(&buf->active_readers)) + return 1; + } + return 0; +} + static void ltt_buffer_read_close(struct lib_ring_buffer *buf) { @@ -186,7 +206,7 @@ void ltt_buffer_read_close(struct lib_ring_buffer *buf) } static -int ltt_event_reserve(struct lib_ring_buffer_ctx *ctx) +int ltt_event_reserve(struct lib_ring_buffer_ctx *ctx, uint32_t event_id) { return lib_ring_buffer_reserve(&client_config, ctx); } @@ -205,9 +225,60 @@ void ltt_event_write(struct lib_ring_buffer_ctx *ctx, const void *src, } static -wait_queue_head_t *ltt_get_reader_wait_queue(struct ltt_channel *chan) +void ltt_event_write_from_user(struct lib_ring_buffer_ctx *ctx, + const void __user *src, size_t len) +{ + lib_ring_buffer_copy_from_user(&client_config, ctx, src, len); +} + +static +void ltt_event_memset(struct lib_ring_buffer_ctx *ctx, + int c, size_t len) +{ + lib_ring_buffer_memset(&client_config, ctx, c, len); +} + +static +size_t ltt_packet_avail_size(struct channel *chan) + +{ + unsigned long o_begin; + struct lib_ring_buffer *buf; + + buf = chan->backend.buf; /* Only for global buffer ! */ + o_begin = v_read(&client_config, &buf->offset); + if (subbuf_offset(o_begin, chan) != 0) { + return chan->backend.subbuf_size - subbuf_offset(o_begin, chan); + } else { + return chan->backend.subbuf_size - subbuf_offset(o_begin, chan) + - sizeof(struct metadata_packet_header); + } +} + +static +wait_queue_head_t *ltt_get_writer_buf_wait_queue(struct channel *chan, int cpu) +{ + struct lib_ring_buffer *buf = channel_get_ring_buffer(&client_config, + chan, cpu); + return &buf->write_wait; +} + +static +wait_queue_head_t *ltt_get_hp_wait_queue(struct channel *chan) +{ + return &chan->hp_wait; +} + +static +int ltt_is_finalized(struct channel *chan) +{ + return lib_ring_buffer_channel_is_finalized(chan); +} + +static +int ltt_is_disabled(struct channel *chan) { - return &chan->chan->read_wait; + return lib_ring_buffer_channel_is_disabled(chan); } static struct ltt_transport ltt_relay_transport = { @@ -217,11 +288,19 @@ static struct ltt_transport ltt_relay_transport = { .channel_create = _channel_create, .channel_destroy = ltt_channel_destroy, .buffer_read_open = ltt_buffer_read_open, + .buffer_has_read_closed_stream = + ltt_buffer_has_read_closed_stream, .buffer_read_close = ltt_buffer_read_close, .event_reserve = ltt_event_reserve, .event_commit = ltt_event_commit, + .event_write_from_user = ltt_event_write_from_user, + .event_memset = ltt_event_memset, .event_write = ltt_event_write, - .get_reader_wait_queue = ltt_get_reader_wait_queue, + .packet_avail_size = ltt_packet_avail_size, + .get_writer_buf_wait_queue = ltt_get_writer_buf_wait_queue, + .get_hp_wait_queue = ltt_get_hp_wait_queue, + .is_finalized = ltt_is_finalized, + .is_disabled = ltt_is_disabled, }, }; @@ -232,7 +311,6 @@ static int __init ltt_ring_buffer_client_init(void) * 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; } @@ -241,7 +319,6 @@ 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); }