X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=liblttng-ust%2Fltt-events.c;h=7882f6d2a63b84fdc0a2659b69d3e6e6d99027c0;hb=3431ca3eea9bfaab6ced44922beb9e6bb7a2abc1;hp=fc7dfc7c78a7334f6676e8b6ac9b2242a3bae855;hpb=c1fca4572d4458b2e6e96752f9efc595c5f72405;p=lttng-ust.git diff --git a/liblttng-ust/ltt-events.c b/liblttng-ust/ltt-events.c index fc7dfc7c..7882f6d2 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) { @@ -68,6 +74,7 @@ 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_channel_destroy(struct ltt_channel *chan); static int _ltt_event_unregister(struct ltt_event *event); static @@ -87,7 +94,7 @@ 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); + uint32_t 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); @@ -126,8 +133,48 @@ int pending_probe_fix_events(const struct lttng_event_desc *desc) 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); + uint32_t hash = jhash(name, name_len - 1, 0); int ret = 0; + struct lttng_ust_event event_param; + + /* + * 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); + } + } + } head = &pending_probe_table[hash & (PENDING_PROBE_HASH_SIZE - 1)]; cds_hlist_for_each_entry_safe(e, node, p, head, node) { @@ -168,6 +215,7 @@ 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); uuid_generate(session->uuid); cds_list_add(&session->list, &sessions); return session; @@ -177,6 +225,7 @@ void ltt_session_destroy(struct ltt_session *session) { struct ltt_channel *chan, *tmpchan; struct ltt_event *event, *tmpevent; + struct session_loglevel *loglevel, *tmploglevel; int ret; CMM_ACCESS_ONCE(session->active) = 0; @@ -185,6 +234,8 @@ 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(event, tmpevent, &session->events, list) _ltt_event_destroy(event); cds_list_for_each_entry_safe(chan, tmpchan, &session->chan, list) @@ -293,9 +344,10 @@ struct ltt_channel *ltt_channel_create(struct ltt_session *session, unsigned int switch_timer_interval, unsigned int read_timer_interval, int *shm_fd, int *wait_fd, - uint64_t *memory_map_size) + 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) @@ -306,21 +358,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; @@ -328,8 +377,6 @@ struct ltt_channel *ltt_channel_create(struct ltt_session *session, return chan; create_error: - free(chan); -nomem: notransport: active: return NULL; @@ -341,34 +388,61 @@ 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); } /* * 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 && !strcmp(event->desc->name, event_param->name)) { + 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; /* @@ -401,6 +475,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); } @@ -410,7 +487,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) { @@ -425,7 +503,7 @@ register_error: cache_error: exist: full: - return NULL; + return ret; } /* @@ -723,7 +801,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,