X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=libust%2Fltt-events.c;h=0c6ef373079b417bc44a66e10e0f2dd0638706bb;hb=594696b1d28139d4a6ff85389e39970460b9e778;hp=f048e27817a69cb9f1aee3c23f41c4d1360341a7;hpb=f4681817263e0d8daa2839da41ea3ef666d6bc1b;p=lttng-ust.git diff --git a/libust/ltt-events.c b/libust/ltt-events.c index f048e278..0c6ef373 100644 --- a/libust/ltt-events.c +++ b/libust/ltt-events.c @@ -11,6 +11,7 @@ #define _GNU_SOURCE #include #include +#include #include #include #include @@ -21,14 +22,49 @@ #include #include #include -#include "usterr_signal_safe.h" +#include #include "ust/core.h" #include "ltt-tracer.h" +#include "ltt-tracer-core.h" #include "ust/wait.h" +#include "../libringbuffer/shm.h" + +typedef u32 uint32_t; +#include + +/* + * The sessions mutex is the centralized mutex across UST tracing + * control and probe registration. + */ +static DEFINE_MUTEX(sessions_mutex); + +void lock_ust(void) +{ + pthread_mutex_lock(&sessions_mutex); +} + +void unlock_ust(void) +{ + pthread_mutex_unlock(&sessions_mutex); +} static CDS_LIST_HEAD(sessions); static CDS_LIST_HEAD(ltt_transport_list); -static DEFINE_MUTEX(sessions_mutex); + +/* + * Pending probes hash table, containing the registered ltt events for + * which tracepoint probes are still missing. Protected by the sessions + * mutex. + */ +#define PENDING_PROBE_HASH_BITS 6 +#define PENDING_PROBE_HASH_SIZE (1 << PENDING_PROBE_HASH_BITS) +static struct cds_hlist_head pending_probe_table[PENDING_PROBE_HASH_SIZE]; + +struct ust_pending_probe { + struct ltt_event *event; + struct cds_hlist_node node; + char name[]; +}; static void _ltt_event_destroy(struct ltt_event *event); static void _ltt_channel_destroy(struct ltt_channel *chan); @@ -40,6 +76,80 @@ int _ltt_event_metadata_statedump(struct ltt_session *session, static int _ltt_session_metadata_statedump(struct ltt_session *session); +/* + * called at event creation if probe is missing. + * called with session mutex held. + */ +static +int add_pending_probe(struct ltt_event *event, const char *name) +{ + struct cds_hlist_head *head; + struct ust_pending_probe *e; + size_t name_len = strlen(name) + 1; + u32 hash = jhash(name, name_len - 1, 0); + + head = &pending_probe_table[hash & (PENDING_PROBE_HASH_SIZE - 1)]; + e = zmalloc(sizeof(struct ust_pending_probe) + name_len); + if (!e) + return -ENOMEM; + memcpy(&e->name[0], name, name_len); + cds_hlist_add_head(&e->node, head); + e->event = event; + event->pending_probe = e; + return 0; +} + +/* + * remove a pending probe. called when at event teardown and when an + * event is fixed (probe is loaded). + * called with session mutex held. + */ +static +void remove_pending_probe(struct ust_pending_probe *e) +{ + if (!e) + return; + cds_hlist_del(&e->node); + free(e); +} + +/* + * Called at library load: connect the probe on the events pending on + * probe load. + * called with session mutex held. + */ +int pending_probe_fix_events(const struct lttng_event_desc *desc) +{ + struct cds_hlist_head *head; + struct cds_hlist_node *node, *p; + struct ust_pending_probe *e; + const char *name = desc->name; + size_t name_len = strlen(name) + 1; + u32 hash = jhash(name, name_len - 1, 0); + int ret = 0; + + head = &pending_probe_table[hash & (PENDING_PROBE_HASH_SIZE - 1)]; + cds_hlist_for_each_entry_safe(e, node, p, head, node) { + struct ltt_event *event; + struct ltt_channel *chan; + + if (strcmp(name, e->name)) + continue; + event = e->event; + chan = event->chan; + assert(!event->desc); + event->desc = desc; + event->pending_probe = NULL; + remove_pending_probe(e); + ret |= __tracepoint_probe_register(name, + event->desc->probe_callback, + event); + ret |= _ltt_event_metadata_statedump(chan->session, chan, + event); + } + return ret; +} + void synchronize_trace(void) { synchronize_rcu(); @@ -49,10 +159,10 @@ struct ltt_session *ltt_session_create(void) { struct ltt_session *session; - pthread_mutex_lock(&sessions_mutex); session = zmalloc(sizeof(struct ltt_session)); if (!session) return NULL; + pthread_mutex_lock(&sessions_mutex); CDS_INIT_LIST_HEAD(&session->chan); CDS_INIT_LIST_HEAD(&session->events); uuid_generate(session->uuid); @@ -215,15 +325,14 @@ struct ltt_channel *ltt_channel_create(struct ltt_session *session, goto nomem; chan->session = session; chan->id = session->free_chan_id++; - //chan->shmid = shmget(getpid(), shmlen, IPC_CREAT | IPC_EXCL | 0700); /* * Note: the channel creation op already writes into the packet * headers. Therefore the "chan" information used as input * should be already accessible. */ - chan->chan = transport->ops.channel_create("[lttng]", chan, buf_addr, + transport->ops.channel_create("[lttng]", chan, buf_addr, subbuf_size, num_subbuf, switch_timer_interval, - read_timer_interval, shmid); + read_timer_interval); if (!chan->chan) goto create_error; chan->enabled = 1; @@ -247,7 +356,7 @@ active: static void _ltt_channel_destroy(struct ltt_channel *chan) { - chan->ops->channel_destroy(chan->chan); + chan->ops->channel_destroy(chan); cds_list_del(&chan->list); lttng_destroy_context(chan->ctx); free(chan); @@ -264,21 +373,25 @@ struct ltt_event *ltt_event_create(struct ltt_channel *chan, int ret; pthread_mutex_lock(&sessions_mutex); - if (chan->free_event_id == -1UL) + if (chan->used_event_id == -1UL) goto full; /* * This is O(n^2) (for each event, the loop is called at event * creation). Might require a hash if we have lots of events. */ cds_list_for_each_entry(event, &chan->session->events, list) - if (!strcmp(event->desc->name, event_param->name)) + if (event->desc && !strcmp(event->desc->name, event_param->name)) goto exist; event = zmalloc(sizeof(struct ltt_event)); if (!event) goto cache_error; event->chan = chan; event->filter = filter; - event->id = chan->free_event_id++; + /* + * used_event_id counts the maximum number of event IDs that can + * register if all probes register. + */ + chan->used_event_id++; event->enabled = 1; event->instrumentation = event_param->instrumentation; /* Populate ltt_event structure before tracepoint registration. */ @@ -286,29 +399,44 @@ struct ltt_event *ltt_event_create(struct ltt_channel *chan, switch (event_param->instrumentation) { case LTTNG_UST_TRACEPOINT: event->desc = ltt_event_get(event_param->name); - if (!event->desc) - goto register_error; - ret = __tracepoint_probe_register(event_param->name, - event->desc->probe_callback, - event); - if (ret) - goto register_error; + if (event->desc) { + ret = __tracepoint_probe_register(event_param->name, + event->desc->probe_callback, + event); + if (ret) + goto register_error; + event->id = chan->free_event_id++; + } else { + /* + * If the probe is not present, event->desc stays NULL, + * waiting for the probe to register, and the event->id + * stays unallocated. + */ + ret = add_pending_probe(event, event_param->name); + if (ret) + goto add_pending_error; + } break; default: WARN_ON_ONCE(1); } - ret = _ltt_event_metadata_statedump(chan->session, chan, event); - if (ret) - goto statedump_error; + if (event->desc) { + ret = _ltt_event_metadata_statedump(chan->session, chan, event); + if (ret) + goto statedump_error; + } cds_list_add(&event->list, &chan->session->events); pthread_mutex_unlock(&sessions_mutex); return event; statedump_error: - WARN_ON_ONCE(__tracepoint_probe_unregister(event_param->name, - event->desc->probe_callback, - event)); - ltt_event_put(event->desc); + if (event->desc) { + WARN_ON_ONCE(__tracepoint_probe_unregister(event_param->name, + event->desc->probe_callback, + event)); + ltt_event_put(event->desc); + } +add_pending_error: register_error: free(event); cache_error: @@ -327,11 +455,16 @@ int _ltt_event_unregister(struct ltt_event *event) switch (event->instrumentation) { case LTTNG_UST_TRACEPOINT: - ret = __tracepoint_probe_unregister(event->desc->name, - event->desc->probe_callback, - event); - if (ret) - return ret; + if (event->desc) { + ret = __tracepoint_probe_unregister(event->desc->name, + event->desc->probe_callback, + event); + if (ret) + return ret; + } else { + remove_pending_probe(event->pending_probe); + ret = 0; + } break; default: WARN_ON_ONCE(1); @@ -347,7 +480,9 @@ void _ltt_event_destroy(struct ltt_event *event) { switch (event->instrumentation) { case LTTNG_UST_TRACEPOINT: - ltt_event_put(event->desc); + if (event->desc) { + ltt_event_put(event->desc); + } break; default: WARN_ON_ONCE(1); @@ -386,10 +521,10 @@ int lttng_metadata_printf(struct ltt_session *session, for (pos = 0; pos < len; pos += reserve_len) { reserve_len = min_t(size_t, - chan->ops->packet_avail_size(chan->chan), + chan->ops->packet_avail_size(chan->chan, chan->handle), len - pos); lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, reserve_len, - sizeof(char), -1); + sizeof(char), -1, chan->handle); /* * We don't care about metadata buffer's records lost * count, because we always retry here. Report error if @@ -402,7 +537,7 @@ int lttng_metadata_printf(struct ltt_session *session, ret != -ENOBUFS || !ret; }), LTTNG_METADATA_TIMEOUT_MSEC); - if (!waitret || waitret == -EINTR || ret) { + if (waitret == -ETIMEDOUT || waitret == -EINTR || ret) { DBG("LTTng: Failure to write metadata to buffers (%s)\n", waitret == -EINTR ? "interrupted" : (ret == -ENOBUFS ? "timeout" : "I/O error")); @@ -598,6 +733,11 @@ int _ltt_event_metadata_statedump(struct ltt_session *session, return 0; if (chan == session->metadata) return 0; + /* + * Don't print events for which probe load is pending. + */ + if (!event->desc) + return 0; ret = lttng_metadata_printf(session, "event {\n" @@ -752,8 +892,8 @@ int _ltt_event_header_declare(struct ltt_session *session) " } extended;\n" " } v;\n" "} align(%u);\n\n", - ltt_alignof(uint32_t) * CHAR_BIT, - ltt_alignof(uint16_t) * CHAR_BIT + lttng_alignof(uint32_t) * CHAR_BIT, + lttng_alignof(uint16_t) * CHAR_BIT ); } @@ -804,10 +944,10 @@ int _ltt_session_metadata_statedump(struct ltt_session *session) " uint32_t stream_id;\n" " };\n" "};\n\n", - ltt_alignof(uint8_t) * CHAR_BIT, - ltt_alignof(uint16_t) * CHAR_BIT, - ltt_alignof(uint32_t) * CHAR_BIT, - ltt_alignof(uint64_t) * CHAR_BIT, + lttng_alignof(uint8_t) * CHAR_BIT, + lttng_alignof(uint16_t) * CHAR_BIT, + lttng_alignof(uint32_t) * CHAR_BIT, + lttng_alignof(uint64_t) * CHAR_BIT, CTF_VERSION_MAJOR, CTF_VERSION_MINOR, uuid_s, @@ -870,8 +1010,7 @@ void ltt_transport_unregister(struct ltt_transport *transport) pthread_mutex_unlock(&sessions_mutex); } -static -void __attribute__((destructor)) ltt_events_exit(void) +void ltt_events_exit(void) { struct ltt_session *session, *tmpsession;