X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Ftrace-ust.c;h=1830763b1b6a88d3c1ac7ba528d5512b3e7444a3;hp=d1e8b8dae117a4369d35681a0e6d7462b0f136c3;hb=0525e9ae15d215943d8187e7f190d5a45e723085;hpb=a4b92340642035d1eafeb1eead0ad01f64d2007d diff --git a/src/bin/lttng-sessiond/trace-ust.c b/src/bin/lttng-sessiond/trace-ust.c index d1e8b8dae..1830763b1 100644 --- a/src/bin/lttng-sessiond/trace-ust.c +++ b/src/bin/lttng-sessiond/trace-ust.c @@ -26,6 +26,95 @@ #include "trace-ust.h" +/* + * Match function for the events hash table lookup. + * + * Matches by name only. Used by the disable command. + */ +int trace_ust_ht_match_event_by_name(struct cds_lfht_node *node, + const void *_key) +{ + struct ltt_ust_event *event; + const char *name; + + assert(node); + assert(_key); + + event = caa_container_of(node, struct ltt_ust_event, node.node); + name = _key; + + /* Event name */ + if (strncmp(event->attr.name, name, sizeof(event->attr.name)) != 0) { + goto no_match; + } + + /* Match */ + return 1; + +no_match: + return 0; +} + +/* + * Match function for the hash table lookup. + * + * It matches an ust event based on three attributes which are the event name, + * the filter bytecode and the loglevel. + */ +int trace_ust_ht_match_event(struct cds_lfht_node *node, const void *_key) +{ + struct ltt_ust_event *event; + const struct ltt_ust_ht_key *key; + + assert(node); + assert(_key); + + event = caa_container_of(node, struct ltt_ust_event, node.node); + key = _key; + + /* Match the 3 elements of the key: name, filter and loglevel. */ + + /* Event name */ + if (strncmp(event->attr.name, key->name, sizeof(event->attr.name)) != 0) { + goto no_match; + } + + /* Event loglevel. */ + if (event->attr.loglevel != key->loglevel) { + if (event->attr.loglevel_type == LTTNG_UST_LOGLEVEL_ALL + && key->loglevel == 0 && event->attr.loglevel == -1) { + /* + * Match is accepted. This is because on event creation, the + * loglevel is set to -1 if the event loglevel type is ALL so 0 and + * -1 are accepted for this loglevel type since 0 is the one set by + * the API when receiving an enable event. + */ + } else { + goto no_match; + } + } + + /* Only one of the filters is NULL, fail. */ + if ((key->filter && !event->filter) || (!key->filter && event->filter)) { + goto no_match; + } + + if (key->filter && event->filter) { + /* Both filters exists, check length followed by the bytecode. */ + if (event->filter->len != key->filter->len || + memcmp(event->filter->data, key->filter->data, + event->filter->len) != 0) { + goto no_match; + } + } + + /* Match. */ + return 1; + +no_match: + return 0; +} + /* * Find the channel in the hashtable. */ @@ -56,27 +145,33 @@ error: /* * Find the event in the hashtable. */ -struct ltt_ust_event *trace_ust_find_event_by_name(struct lttng_ht *ht, - char *name) +struct ltt_ust_event *trace_ust_find_event(struct lttng_ht *ht, + char *name, struct lttng_filter_bytecode *filter, int loglevel) { struct lttng_ht_node_str *node; struct lttng_ht_iter iter; + struct ltt_ust_ht_key key; - rcu_read_lock(); - lttng_ht_lookup(ht, (void *) name, &iter); + assert(name); + assert(ht); + + key.name = name; + key.filter = filter; + key.loglevel = loglevel; + + cds_lfht_lookup(ht->ht, ht->hash_fct((void *) name, lttng_ht_seed), + trace_ust_ht_match_event, &key, &iter.iter); node = lttng_ht_iter_get_node_str(&iter); if (node == NULL) { - rcu_read_unlock(); goto error; } - rcu_read_unlock(); - DBG2("Trace UST event found by name %s", name); + DBG2("Trace UST event %s found", key.name); return caa_container_of(node, struct ltt_ust_event, node); error: - DBG2("Trace UST event NOT found by name %s", name); + DBG2("Trace UST event %s NOT found", key.name); return NULL; } @@ -88,7 +183,6 @@ error: struct ltt_ust_session *trace_ust_create_session(char *path, unsigned int session_id, struct lttng_domain *domain) { - int ret; struct ltt_ust_session *lus; /* Allocate a new ltt ust session */ @@ -111,7 +205,7 @@ struct ltt_ust_session *trace_ust_create_session(char *path, lus->consumer = consumer_create_output(CONSUMER_DST_LOCAL); if (lus->consumer == NULL) { - goto error_free_session; + goto error_consumer; } /* @@ -124,11 +218,13 @@ struct ltt_ust_session *trace_ust_create_session(char *path, /* Use the default consumer output which is the tracing session path. */ if (path && strlen(path) > 0) { + int ret; + ret = snprintf(lus->consumer->dst.trace_path, PATH_MAX, "%s" DEFAULT_UST_TRACE_DIR, path); if (ret < 0) { PERROR("snprintf UST consumer trace path"); - goto error; + goto error_path; } /* Set session path */ @@ -136,7 +232,7 @@ struct ltt_ust_session *trace_ust_create_session(char *path, path); if (ret < 0) { PERROR("snprintf kernel traces path"); - goto error_free_session; + goto error_path; } } @@ -144,7 +240,9 @@ struct ltt_ust_session *trace_ust_create_session(char *path, return lus; -error_free_session: +error_path: + consumer_destroy_output(lus->consumer); +error_consumer: lttng_ht_destroy(lus->domain_global.channels); lttng_ht_destroy(lus->domain_exec); lttng_ht_destroy(lus->domain_pid); @@ -164,6 +262,9 @@ struct ltt_ust_channel *trace_ust_create_channel(struct lttng_channel *chan, int ret; struct ltt_ust_channel *luc; + assert(chan); + assert(path); + luc = zmalloc(sizeof(struct ltt_ust_channel)); if (luc == NULL) { PERROR("ltt_ust_channel zmalloc"); @@ -219,10 +320,13 @@ error: * * Return pointer to structure or NULL. */ -struct ltt_ust_event *trace_ust_create_event(struct lttng_event *ev) +struct ltt_ust_event *trace_ust_create_event(struct lttng_event *ev, + struct lttng_filter_bytecode *filter) { struct ltt_ust_event *lue; + assert(ev); + lue = zmalloc(sizeof(struct ltt_ust_event)); if (lue == NULL) { PERROR("ust event zmalloc"); @@ -269,15 +373,11 @@ struct ltt_ust_event *trace_ust_create_event(struct lttng_event *ev) goto error_free_event; } + /* Same layout. */ + lue->filter = (struct lttng_ust_filter_bytecode *) filter; /* Init node */ lttng_ht_node_init_str(&lue->node, lue->attr.name); - /* Alloc context hash tables */ - lue->ctx = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG); - if (lue->ctx == NULL) { - ERR("Unable to create context hash table for event %s", ev->name); - goto error_free_event; - } DBG2("Trace UST event %s, loglevel (%d,%d) created", lue->attr.name, lue->attr.loglevel_type, @@ -301,6 +401,8 @@ struct ltt_ust_metadata *trace_ust_create_metadata(char *path) int ret; struct ltt_ust_metadata *lum; + assert(path); + lum = zmalloc(sizeof(struct ltt_ust_metadata)); if (lum == NULL) { PERROR("ust metadata zmalloc"); @@ -309,7 +411,7 @@ struct ltt_ust_metadata *trace_ust_create_metadata(char *path) /* Set default attributes */ lum->attr.overwrite = DEFAULT_CHANNEL_OVERWRITE; - lum->attr.subbuf_size = DEFAULT_METADATA_SUBBUF_SIZE; + lum->attr.subbuf_size = default_get_metadata_subbuf_size(); lum->attr.num_subbuf = DEFAULT_METADATA_SUBBUF_NUM; lum->attr.switch_timer_interval = DEFAULT_CHANNEL_SWITCH_TIMER; lum->attr.read_timer_interval = DEFAULT_CHANNEL_READ_TIMER; @@ -342,6 +444,8 @@ struct ltt_ust_context *trace_ust_create_context( struct ltt_ust_context *uctx; enum lttng_ust_context_type utype; + assert(ctx); + switch (ctx->ctx) { case LTTNG_EVENT_CONTEXT_VTID: utype = LTTNG_UST_CONTEXT_VTID; @@ -397,6 +501,8 @@ static void destroy_contexts(struct lttng_ht *ht) struct lttng_ht_node_ulong *node; struct lttng_ht_iter iter; + assert(ht); + cds_lfht_for_each_entry(ht->ht, &iter.iter, node, node) { ret = lttng_ht_del(ht, &iter); if (!ret) { @@ -412,8 +518,9 @@ static void destroy_contexts(struct lttng_ht *ht) */ void trace_ust_destroy_event(struct ltt_ust_event *event) { + assert(event); + DBG2("Trace destroy UST event %s", event->attr.name); - destroy_contexts(event->ctx); free(event->filter); free(event); } @@ -440,6 +547,8 @@ static void destroy_events(struct lttng_ht *events) struct lttng_ht_node_str *node; struct lttng_ht_iter iter; + assert(events); + cds_lfht_for_each_entry(events->ht, &iter.iter, node, node) { ret = lttng_ht_del(events, &iter); assert(!ret); @@ -454,6 +563,8 @@ static void destroy_events(struct lttng_ht *events) */ void trace_ust_destroy_channel(struct ltt_ust_channel *channel) { + assert(channel); + DBG2("Trace destroy UST channel %s", channel->name); rcu_read_lock(); @@ -486,6 +597,8 @@ static void destroy_channel_rcu(struct rcu_head *head) */ void trace_ust_destroy_metadata(struct ltt_ust_metadata *metadata) { + assert(metadata); + if (!metadata->handle) { return; } @@ -502,6 +615,8 @@ static void destroy_channels(struct lttng_ht *channels) struct lttng_ht_node_str *node; struct lttng_ht_iter iter; + assert(channels); + rcu_read_lock(); cds_lfht_for_each_entry(channels->ht, &iter.iter, node, node) { @@ -524,6 +639,8 @@ static void destroy_domain_pid(struct lttng_ht *ht) struct lttng_ht_iter iter; struct ltt_ust_domain_pid *dpid; + assert(ht); + cds_lfht_for_each_entry(ht->ht, &iter.iter, dpid, node.node) { ret = lttng_ht_del(ht , &iter); assert(!ret); @@ -542,6 +659,8 @@ static void destroy_domain_exec(struct lttng_ht *ht) struct lttng_ht_iter iter; struct ltt_ust_domain_exec *dexec; + assert(ht); + cds_lfht_for_each_entry(ht->ht, &iter.iter, dexec, node.node) { ret = lttng_ht_del(ht , &iter); assert(!ret); @@ -556,6 +675,8 @@ static void destroy_domain_exec(struct lttng_ht *ht) */ static void destroy_domain_global(struct ltt_ust_domain_global *dom) { + assert(dom); + destroy_channels(dom->channels); } @@ -564,10 +685,7 @@ static void destroy_domain_global(struct ltt_ust_domain_global *dom) */ void trace_ust_destroy_session(struct ltt_ust_session *session) { - /* Extra protection */ - if (session == NULL) { - return; - } + assert(session); rcu_read_lock(); @@ -578,6 +696,9 @@ void trace_ust_destroy_session(struct ltt_ust_session *session) destroy_domain_pid(session->domain_pid); destroy_domain_exec(session->domain_exec); + consumer_destroy_output(session->consumer); + consumer_destroy_output(session->tmp_consumer); + free(session); rcu_read_unlock();