X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust%2Fltt-events.c;h=ee88b43142d6e39c57f974102ba45328a7aef210;hb=ef9ff354212ff4b038e1a5b6a7ed0ffe1b949663;hp=68531bcd628e435e62805d52b5f593054ec5089b;hpb=69400ac4a4e6575f749c6326df7c2a2c8ac3bdc5;p=lttng-ust.git diff --git a/liblttng-ust/ltt-events.c b/liblttng-ust/ltt-events.c index 68531bcd..ee88b431 100644 --- a/liblttng-ust/ltt-events.c +++ b/liblttng-ust/ltt-events.c @@ -14,31 +14,37 @@ #include #include #include -#include -#include -#include #include -#include #include #include #include +#include +#include + +#include +#include +#include +#include + +#include #include -#include -#include "lttng/core.h" + +#include +#include +#include "error.h" + #include "ltt-tracer.h" #include "ltt-tracer-core.h" -#include "lttng/wait.h" +#include "wait.h" #include "../libringbuffer/shm.h" - -typedef u32 uint32_t; -#include +#include "jhash.h" /* * The sessions mutex is the centralized mutex across UST tracing * control and probe registration. All operations within this file are * called by the communication thread, under ust_lock protection. */ -static DEFINE_MUTEX(sessions_mutex); +static pthread_mutex_t sessions_mutex = PTHREAD_MUTEX_INITIALIZER; void ust_lock(void) { @@ -51,7 +57,6 @@ void ust_unlock(void) } static CDS_LIST_HEAD(sessions); -static CDS_LIST_HEAD(ltt_transport_list); /* * Pending probes hash table, containing the registered ltt events for @@ -69,6 +74,8 @@ struct ust_pending_probe { }; static void _ltt_event_destroy(struct ltt_event *event); +static void _ltt_loglevel_destroy(struct session_loglevel *sl); +static void _ltt_wildcard_destroy(struct session_wildcard *sw); static void _ltt_channel_destroy(struct ltt_channel *chan); static int _ltt_event_unregister(struct ltt_event *event); static @@ -87,14 +94,20 @@ 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); + size_t name_len = strlen(name); + uint32_t hash; + if (name_len > LTTNG_UST_SYM_NAME_LEN - 1) { + WARN("Truncating tracepoint name %s which exceeds size limits of %u chars", name, LTTNG_UST_SYM_NAME_LEN - 1); + name_len = LTTNG_UST_SYM_NAME_LEN - 1; + } + hash = jhash(name, name_len, 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); + memcpy(&e->name[0], name, name_len + 1); + e->name[name_len] = '\0'; cds_hlist_add_head(&e->node, head); e->event = event; event->pending_probe = e; @@ -126,16 +139,93 @@ int pending_probe_fix_events(const struct lttng_event_desc *desc) 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; + struct lttng_ust_event event_param; + size_t name_len = strlen(name); + uint32_t hash; + + /* + * For this event, we need to lookup the loglevel. If active (in + * the active loglevels hash table), we must create the event. + */ + if (desc->loglevel) { + const struct tracepoint_loglevel_entry *ev_ll; + struct loglevel_entry *loglevel; + + ev_ll = *desc->loglevel; + loglevel = get_loglevel(ev_ll->identifier); + if (!loglevel) + loglevel = get_loglevel_value(ev_ll->value); + if (loglevel) { + struct session_loglevel *sl; + + cds_list_for_each_entry(sl, &loglevel->session_list, + session_list) { + struct ltt_event *ev; + int ret; + + memcpy(&event_param, &sl->event_param, + sizeof(event_param)); + memcpy(event_param.name, + desc->name, + sizeof(event_param.name)); + /* create event */ + ret = ltt_event_create(sl->chan, + &event_param, NULL, + &ev); + if (ret) { + DBG("Error creating event"); + continue; + } + cds_list_add(&ev->loglevel_list, + &sl->events); + } + } + } + + /* Wildcard */ + { + struct wildcard_entry *wildcard; + + wildcard = match_wildcard(desc->name); + if (strcmp(desc->name, "lttng_ust:metadata") && wildcard) { + struct session_wildcard *sw; + + cds_list_for_each_entry(sw, &wildcard->session_list, + session_list) { + struct ltt_event *ev; + int ret; + + memcpy(&event_param, &sw->event_param, + sizeof(event_param)); + memcpy(event_param.name, + desc->name, + sizeof(event_param.name)); + /* create event */ + ret = ltt_event_create(sw->chan, + &event_param, NULL, + &ev); + if (ret) { + DBG("Error creating event"); + continue; + } + cds_list_add(&ev->wildcard_list, + &sw->events); + } + } + } + if (name_len > LTTNG_UST_SYM_NAME_LEN - 1) { + WARN("Truncating tracepoint name %s which exceeds size limits of %u chars", name, LTTNG_UST_SYM_NAME_LEN - 1); + name_len = LTTNG_UST_SYM_NAME_LEN - 1; + } + hash = jhash(name, name_len, 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)) + if (strncmp(name, e->name, LTTNG_UST_SYM_NAME_LEN - 1)) continue; event = e->event; chan = event->chan; @@ -169,6 +259,8 @@ struct ltt_session *ltt_session_create(void) return NULL; CDS_INIT_LIST_HEAD(&session->chan); CDS_INIT_LIST_HEAD(&session->events); + CDS_INIT_LIST_HEAD(&session->loglevels); + CDS_INIT_LIST_HEAD(&session->wildcards); uuid_generate(session->uuid); cds_list_add(&session->list, &sessions); return session; @@ -178,6 +270,8 @@ void ltt_session_destroy(struct ltt_session *session) { struct ltt_channel *chan, *tmpchan; struct ltt_event *event, *tmpevent; + struct session_loglevel *loglevel, *tmploglevel; + struct session_wildcard *wildcard, *tmpwildcard; int ret; CMM_ACCESS_ONCE(session->active) = 0; @@ -186,6 +280,10 @@ void ltt_session_destroy(struct ltt_session *session) WARN_ON(ret); } synchronize_trace(); /* Wait for in-flight events to complete */ + cds_list_for_each_entry_safe(loglevel, tmploglevel, &session->loglevels, list) + _ltt_loglevel_destroy(loglevel); + cds_list_for_each_entry_safe(wildcard, tmpwildcard, &session->wildcards, list) + _ltt_wildcard_destroy(wildcard); cds_list_for_each_entry_safe(event, tmpevent, &session->events, list) _ltt_event_destroy(event); cds_list_for_each_entry_safe(chan, tmpchan, &session->chan, list) @@ -211,10 +309,20 @@ int ltt_session_enable(struct ltt_session *session) cds_list_for_each_entry(chan, &session->chan, list) { if (chan->header_type) continue; /* don't change it if session stop/restart */ + /* + * Because we don't use any timer in the application, we + * currently cannot guarantee that we have frequent + * events that let us detect 27-bit overflows. + * Therefore, for now, we force large event headers, + * which contain 64-bit timestamps. + */ + chan->header_type = 2; /* large */ +#if 0 if (chan->free_event_id < 31) chan->header_type = 1; /* compact */ else chan->header_type = 2; /* large */ +#endif //0 } CMM_ACCESS_ONCE(session->active) = 1; @@ -287,27 +395,17 @@ int ltt_event_disable(struct ltt_event *event) return 0; } -static struct ltt_transport *ltt_transport_find(const char *name) -{ - struct ltt_transport *transport; - - cds_list_for_each_entry(transport, <t_transport_list, node) { - if (!strcmp(transport->name, name)) - return transport; - } - return NULL; -} - struct ltt_channel *ltt_channel_create(struct ltt_session *session, const char *transport_name, void *buf_addr, size_t subbuf_size, size_t num_subbuf, unsigned int switch_timer_interval, unsigned int read_timer_interval, - int *shm_fd, int *wait_fd, - uint64_t *memory_map_size) + int **shm_fd, int **wait_fd, + uint64_t **memory_map_size, + struct ltt_channel *chan_priv_init) { - struct ltt_channel *chan; + struct ltt_channel *chan = NULL; struct ltt_transport *transport; if (session->been_active) @@ -318,21 +416,18 @@ struct ltt_channel *ltt_channel_create(struct ltt_session *session, transport_name); goto notransport; } - chan = zmalloc(sizeof(struct ltt_channel)); - if (!chan) - goto nomem; - chan->session = session; - chan->id = session->free_chan_id++; + chan_priv_init->id = session->free_chan_id++; + chan_priv_init->session = session; /* * Note: the channel creation op already writes into the packet * headers. Therefore the "chan" information used as input * should be already accessible. */ - transport->ops.channel_create("[lttng]", chan, buf_addr, + chan = transport->ops.channel_create("[lttng]", buf_addr, subbuf_size, num_subbuf, switch_timer_interval, read_timer_interval, shm_fd, wait_fd, - memory_map_size); - if (!chan->chan) + memory_map_size, chan_priv_init); + if (!chan) goto create_error; chan->enabled = 1; chan->ops = &transport->ops; @@ -340,8 +435,6 @@ struct ltt_channel *ltt_channel_create(struct ltt_session *session, return chan; create_error: - free(chan); -nomem: notransport: active: return NULL; @@ -353,34 +446,83 @@ active: static void _ltt_channel_destroy(struct ltt_channel *chan) { - chan->ops->channel_destroy(chan); cds_list_del(&chan->list); lttng_destroy_context(chan->ctx); - free(chan); + chan->ops->channel_destroy(chan); +} + +int ltt_loglevel_create(struct ltt_channel *chan, + struct lttng_ust_event *event_param, + struct session_loglevel **_sl) +{ + struct session_loglevel *sl; + + sl = add_loglevel(event_param->name, chan, event_param); + if (!sl || IS_ERR(sl)) { + return PTR_ERR(sl); + } + *_sl = sl; + return 0; +} + +static +void _ltt_loglevel_destroy(struct session_loglevel *sl) +{ + _remove_loglevel(sl); +} + +int ltt_wildcard_create(struct ltt_channel *chan, + struct lttng_ust_event *event_param, + struct session_wildcard **_sw) +{ + struct session_wildcard *sw; + + sw = add_wildcard(event_param->name, chan, event_param); + if (!sw || IS_ERR(sw)) { + return PTR_ERR(sw); + } + *_sw = sw; + return 0; +} + +static +void _ltt_wildcard_destroy(struct session_wildcard *sw) +{ + _remove_wildcard(sw); } /* * Supports event creation while tracing session is active. */ -struct ltt_event *ltt_event_create(struct ltt_channel *chan, - struct lttng_ust_event *event_param, - void *filter) +int ltt_event_create(struct ltt_channel *chan, + struct lttng_ust_event *event_param, + void *filter, + struct ltt_event **_event) { struct ltt_event *event; - int ret; + int ret = 0; - if (chan->used_event_id == -1UL) + if (chan->used_event_id == -1UL) { + ret = -ENOMEM; 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 (event->desc && !strcmp(event->desc->name, event_param->name)) + cds_list_for_each_entry(event, &chan->session->events, list) { + if (event->desc && !strncmp(event->desc->name, + event_param->name, + LTTNG_UST_SYM_NAME_LEN - 1)) { + ret = -EEXIST; goto exist; + } + } event = zmalloc(sizeof(struct ltt_event)); - if (!event) + if (!event) { + ret = -ENOMEM; goto cache_error; + } event->chan = chan; event->filter = filter; /* @@ -413,6 +555,9 @@ struct ltt_event *ltt_event_create(struct ltt_channel *chan, goto add_pending_error; } break; + case LTTNG_UST_TRACEPOINT_LOGLEVEL: + assert(0); + break; default: WARN_ON_ONCE(1); } @@ -422,7 +567,8 @@ struct ltt_event *ltt_event_create(struct ltt_channel *chan, goto statedump_error; } cds_list_add(&event->list, &chan->session->events); - return event; + *_event = event; + return 0; statedump_error: if (event->desc) { @@ -437,7 +583,7 @@ register_error: cache_error: exist: full: - return NULL; + return ret; } /* @@ -735,7 +881,7 @@ int _ltt_event_metadata_statedump(struct ltt_session *session, ret = lttng_metadata_printf(session, "event {\n" - " name = %s;\n" + " name = \"%s\";\n" " id = %u;\n" " stream_id = %u;\n", event->desc->name, @@ -744,6 +890,19 @@ int _ltt_event_metadata_statedump(struct ltt_session *session, if (ret) goto end; + if (event->desc->loglevel) { + const struct tracepoint_loglevel_entry *ll_entry; + + ll_entry = *event->desc->loglevel; + ret = lttng_metadata_printf(session, + " loglevel.identifier = \"%s\";\n" + " loglevel.value = %lld;\n", + ll_entry->identifier, + (long long) ll_entry->value); + if (ret) + goto end; + } + if (event->ctx) { ret = lttng_metadata_printf(session, " context := struct {\n"); @@ -979,28 +1138,6 @@ end: return ret; } -/** - * ltt_transport_register - LTT transport registration - * @transport: transport structure - * - * Registers a transport which can be used as output to extract the data out of - * LTTng. Called with ust_lock held. - */ -void ltt_transport_register(struct ltt_transport *transport) -{ - cds_list_add_tail(&transport->node, <t_transport_list); -} - -/** - * ltt_transport_unregister - LTT transport unregistration - * @transport: transport structure - * Called with ust_lock held. - */ -void ltt_transport_unregister(struct ltt_transport *transport) -{ - cds_list_del(&transport->node); -} - void lttng_ust_events_exit(void) { struct ltt_session *session, *tmpsession;