X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Ftrace-ust.c;h=b64597599caaaa9e127306f0c1b0bee806c508f0;hp=9c7cfb690221f11778196bb83fa98209162c4091;hb=0475c50c4d3d2cea973fe4d1f17875d231dea96c;hpb=e71aad1fa4b06a5f91ddceace42366f3d79bd77e diff --git a/src/bin/lttng-sessiond/trace-ust.c b/src/bin/lttng-sessiond/trace-ust.c index 9c7cfb690..b64597599 100644 --- a/src/bin/lttng-sessiond/trace-ust.c +++ b/src/bin/lttng-sessiond/trace-ust.c @@ -1,18 +1,18 @@ /* * Copyright (C) 2011 - David Goulet * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License as published by the Free - * Software Foundation; only version 2 of the License. + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2 only, + * as published by the Free Software Foundation. * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for - * more details. + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. * - * You should have received a copy of the GNU General Public License along with - * this program; if not, write to the Free Software Foundation, Inc., 59 Temple - * Place - Suite 330, Boston, MA 02111-1307, USA. + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #define _GNU_SOURCE @@ -20,14 +20,107 @@ #include #include #include +#include #include #include +#include "buffer-registry.h" #include "trace-ust.h" +#include "utils.h" /* - * Find the channel in the hashtable. + * 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 and return channel pointer. RCU read side + * lock MUST be acquired before calling this. */ struct ltt_ust_channel *trace_ust_find_channel_by_name(struct lttng_ht *ht, char *name) @@ -35,14 +128,18 @@ struct ltt_ust_channel *trace_ust_find_channel_by_name(struct lttng_ht *ht, struct lttng_ht_node_str *node; struct lttng_ht_iter iter; - rcu_read_lock(); + /* + * If we receive an empty string for channel name, it means the + * default channel name is requested. + */ + if (name[0] == '\0') + name = DEFAULT_CHANNEL_NAME; + lttng_ht_lookup(ht, (void *)name, &iter); node = lttng_ht_iter_get_node_str(&iter); if (node == NULL) { - rcu_read_unlock(); goto error; } - rcu_read_unlock(); DBG2("Trace UST channel %s found by name", name); @@ -54,29 +151,36 @@ error: } /* - * Find the event in the hashtable. + * Find the event in the hashtable and return event pointer. RCU read side lock + * MUST be acquired before calling this. */ -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; } @@ -85,8 +189,7 @@ error: * * Return pointer to structure or NULL. */ -struct ltt_ust_session *trace_ust_create_session(char *path, int session_id, - struct lttng_domain *domain) +struct ltt_ust_session *trace_ust_create_session(uint64_t session_id) { int ret; struct ltt_ust_session *lus; @@ -102,25 +205,45 @@ struct ltt_ust_session *trace_ust_create_session(char *path, int session_id, lus->id = session_id; lus->start_trace = 0; - /* Alloc UST domain hash tables */ - lus->domain_pid = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG); - lus->domain_exec = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG); + /* + * Default buffer type. This can be changed through an enable channel + * requesting a different type. Note that this can only be changed once + * during the session lifetime which is at the first enable channel and + * only before start. The flag buffer_type_changed indicates the status. + */ + lus->buffer_type = LTTNG_BUFFER_PER_UID; + /* Once set to 1, the buffer_type is immutable for the session. */ + lus->buffer_type_changed = 0; + /* Init it in case it get used after allocation. */ + CDS_INIT_LIST_HEAD(&lus->buffer_reg_uid_list); /* Alloc UST global domain channels' HT */ lus->domain_global.channels = lttng_ht_new(0, LTTNG_HT_TYPE_STRING); - - /* Set session path */ - ret = snprintf(lus->pathname, PATH_MAX, "%s/ust", path); + ret = jul_init_domain(&lus->domain_jul); if (ret < 0) { - PERROR("snprintf kernel traces path"); - goto error_free_session; + goto error_consumer; } + lus->consumer = consumer_create_output(CONSUMER_DST_LOCAL); + if (lus->consumer == NULL) { + goto error_consumer; + } + + /* + * The tmp_consumer stays NULL until a set_consumer_uri command is + * executed. At this point, the consumer should be nullify until an + * enable_consumer command. This assignment is symbolic since we've zmalloc + * the struct. + */ + lus->tmp_consumer = NULL; + DBG2("UST trace session create successful"); return lus; -error_free_session: +error_consumer: + ht_cleanup_push(lus->domain_global.channels); + jul_destroy_domain(&lus->domain_jul); free(lus); error: return NULL; @@ -131,12 +254,12 @@ error: * * Return pointer to structure or NULL. */ -struct ltt_ust_channel *trace_ust_create_channel(struct lttng_channel *chan, - char *path) +struct ltt_ust_channel *trace_ust_create_channel(struct lttng_channel *chan) { - int ret; struct ltt_ust_channel *luc; + assert(chan); + luc = zmalloc(sizeof(struct ltt_ust_channel)); if (luc == NULL) { PERROR("ltt_ust_channel zmalloc"); @@ -149,7 +272,7 @@ struct ltt_ust_channel *trace_ust_create_channel(struct lttng_channel *chan, luc->attr.num_subbuf = chan->attr.num_subbuf; luc->attr.switch_timer_interval = chan->attr.switch_timer_interval; luc->attr.read_timer_interval = chan->attr.read_timer_interval; - luc->attr.output = chan->attr.output; + luc->attr.output = (enum lttng_ust_output) chan->attr.output; /* Translate to UST output enum */ switch (luc->attr.output) { @@ -158,31 +281,34 @@ struct ltt_ust_channel *trace_ust_create_channel(struct lttng_channel *chan, break; } - /* Copy channel name */ - strncpy(luc->name, chan->name, sizeof(luc->name)); + /* + * If we receive an empty string for channel name, it means the + * default channel name is requested. + */ + if (chan->name[0] == '\0') { + strncpy(luc->name, DEFAULT_CHANNEL_NAME, sizeof(luc->name)); + } else { + /* Copy channel name */ + strncpy(luc->name, chan->name, sizeof(luc->name)); + } luc->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; /* Init node */ lttng_ht_node_init_str(&luc->node, luc->name); + CDS_INIT_LIST_HEAD(&luc->ctx_list); + /* Alloc hash tables */ luc->events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING); luc->ctx = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG); - /* Set trace output path */ - ret = snprintf(luc->pathname, PATH_MAX, "%s", path); - if (ret < 0) { - PERROR("asprintf ust create channel"); - goto error_free_channel; - } + /* On-disk circular buffer parameters */ + luc->tracefile_size = chan->attr.tracefile_size; + luc->tracefile_count = chan->attr.tracefile_count; DBG2("Trace UST channel %s created", luc->name); - return luc; - -error_free_channel: - free(luc); error: - return NULL; + return luc; } /* @@ -190,10 +316,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"); @@ -240,11 +369,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); DBG2("Trace UST event %s, loglevel (%d,%d) created", lue->attr.name, lue->attr.loglevel_type, @@ -268,6 +397,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"); @@ -276,15 +407,15 @@ 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; + lum->attr.switch_timer_interval = DEFAULT_METADATA_SWITCH_TIMER; + lum->attr.read_timer_interval = DEFAULT_METADATA_READ_TIMER; lum->attr.output = LTTNG_UST_MMAP; lum->handle = -1; /* Set metadata trace path */ - ret = snprintf(lum->pathname, PATH_MAX, "%s/metadata", path); + ret = snprintf(lum->pathname, PATH_MAX, "%s/" DEFAULT_METADATA_NAME, path); if (ret < 0) { PERROR("asprintf ust metadata"); goto error_free_metadata; @@ -309,6 +440,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; @@ -322,6 +455,9 @@ struct ltt_ust_context *trace_ust_create_context( case LTTNG_EVENT_CONTEXT_PROCNAME: utype = LTTNG_UST_CONTEXT_PROCNAME; break; + case LTTNG_EVENT_CONTEXT_IP: + utype = LTTNG_UST_CONTEXT_IP; + break; default: ERR("Invalid UST context"); return NULL; @@ -335,6 +471,7 @@ struct ltt_ust_context *trace_ust_create_context( uctx->ctx.ctx = utype; lttng_ht_node_init_ulong(&uctx->node, (unsigned long) uctx->ctx.ctx); + CDS_INIT_LIST_HEAD(&uctx->list); return uctx; @@ -363,15 +500,24 @@ static void destroy_contexts(struct lttng_ht *ht) int ret; struct lttng_ht_node_ulong *node; struct lttng_ht_iter iter; + struct ltt_ust_context *ctx; + + assert(ht); + rcu_read_lock(); cds_lfht_for_each_entry(ht->ht, &iter.iter, node, node) { + /* Remove from ordered list. */ + ctx = caa_container_of(node, struct ltt_ust_context, node); + cds_list_del(&ctx->list); + /* Remove from channel's hash table. */ ret = lttng_ht_del(ht, &iter); if (!ret) { call_rcu(&node->head, destroy_context_rcu); } } + rcu_read_unlock(); - lttng_ht_destroy(ht); + ht_cleanup_push(ht); } /* @@ -379,9 +525,10 @@ static void destroy_contexts(struct lttng_ht *ht) */ void trace_ust_destroy_event(struct ltt_ust_event *event) { - DBG2("Trace destroy UST event %s", event->attr.name); - destroy_contexts(event->ctx); + assert(event); + DBG2("Trace destroy UST event %s", event->attr.name); + free(event->filter); free(event); } @@ -407,23 +554,29 @@ static void destroy_events(struct lttng_ht *events) struct lttng_ht_node_str *node; struct lttng_ht_iter iter; + assert(events); + + rcu_read_lock(); cds_lfht_for_each_entry(events->ht, &iter.iter, node, node) { ret = lttng_ht_del(events, &iter); assert(!ret); call_rcu(&node->head, destroy_event_rcu); } + rcu_read_unlock(); - lttng_ht_destroy(events); + ht_cleanup_push(events); } /* * Cleanup ust channel structure. + * + * Should _NOT_ be called with RCU read lock held. */ -void trace_ust_destroy_channel(struct ltt_ust_channel *channel) +static void _trace_ust_destroy_channel(struct ltt_ust_channel *channel) { - DBG2("Trace destroy UST channel %s", channel->name); + assert(channel); - rcu_read_lock(); + DBG2("Trace destroy UST channel %s", channel->name); /* Destroying all events of the channel */ destroy_events(channel->events); @@ -431,8 +584,6 @@ void trace_ust_destroy_channel(struct ltt_ust_channel *channel) destroy_contexts(channel->ctx); free(channel); - - rcu_read_unlock(); } /* @@ -445,75 +596,66 @@ static void destroy_channel_rcu(struct rcu_head *head) struct ltt_ust_channel *channel = caa_container_of(node, struct ltt_ust_channel, node); - trace_ust_destroy_channel(channel); + _trace_ust_destroy_channel(channel); } -/* - * Cleanup ust metadata structure. - */ -void trace_ust_destroy_metadata(struct ltt_ust_metadata *metadata) +void trace_ust_destroy_channel(struct ltt_ust_channel *channel) { - DBG2("Trace UST destroy metadata %d", metadata->handle); - - free(metadata); + call_rcu(&channel->node.head, destroy_channel_rcu); } /* - * Iterate over a hash table containing channels and cleanup safely. + * Remove an UST channel from a channel HT. */ -static void destroy_channels(struct lttng_ht *channels) +void trace_ust_delete_channel(struct lttng_ht *ht, + struct ltt_ust_channel *channel) { int ret; - struct lttng_ht_node_str *node; struct lttng_ht_iter iter; - rcu_read_lock(); - - cds_lfht_for_each_entry(channels->ht, &iter.iter, node, node) { - ret = lttng_ht_del(channels, &iter); - assert(!ret); - call_rcu(&node->head, destroy_channel_rcu); - } + assert(ht); + assert(channel); - lttng_ht_destroy(channels); - - rcu_read_unlock(); + iter.iter.node = &channel->node.node; + ret = lttng_ht_del(ht, &iter); + assert(!ret); } /* - * Cleanup UST pid domain. + * Cleanup ust metadata structure. */ -static void destroy_domain_pid(struct lttng_ht *ht) +void trace_ust_destroy_metadata(struct ltt_ust_metadata *metadata) { - int ret; - struct lttng_ht_iter iter; - struct ltt_ust_domain_pid *dpid; + assert(metadata); - cds_lfht_for_each_entry(ht->ht, &iter.iter, dpid, node.node) { - ret = lttng_ht_del(ht , &iter); - assert(!ret); - destroy_channels(dpid->channels); + if (!metadata->handle) { + return; } - - lttng_ht_destroy(ht); + DBG2("Trace UST destroy metadata %d", metadata->handle); + free(metadata); } /* - * Cleanup UST exec name domain. + * Iterate over a hash table containing channels and cleanup safely. */ -static void destroy_domain_exec(struct lttng_ht *ht) +static void destroy_channels(struct lttng_ht *channels) { int ret; + struct lttng_ht_node_str *node; struct lttng_ht_iter iter; - struct ltt_ust_domain_exec *dexec; - cds_lfht_for_each_entry(ht->ht, &iter.iter, dexec, node.node) { - ret = lttng_ht_del(ht , &iter); + assert(channels); + + rcu_read_lock(); + + cds_lfht_for_each_entry(channels->ht, &iter.iter, node, node) { + ret = lttng_ht_del(channels, &iter); assert(!ret); - destroy_channels(dexec->channels); + call_rcu(&node->head, destroy_channel_rcu); } + rcu_read_unlock(); - lttng_ht_destroy(ht); + ht_cleanup_push(channels); } /* @@ -521,29 +663,38 @@ 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); } /* * Cleanup ust session structure + * + * Should *NOT* be called with RCU read-side lock held. */ void trace_ust_destroy_session(struct ltt_ust_session *session) { - /* Extra protection */ - if (session == NULL) { - return; - } + struct buffer_reg_uid *reg, *sreg; - rcu_read_lock(); + assert(session); - DBG2("Trace UST destroy session %d", session->id); + DBG2("Trace UST destroy session %" PRIu64, session->id); /* Cleaning up UST domain */ destroy_domain_global(&session->domain_global); - destroy_domain_pid(session->domain_pid); - destroy_domain_exec(session->domain_exec); + jul_destroy_domain(&session->domain_jul); + + /* Cleanup UID buffer registry object(s). */ + cds_list_for_each_entry_safe(reg, sreg, &session->buffer_reg_uid_list, + lnode) { + cds_list_del(®->lnode); + buffer_reg_uid_remove(reg); + buffer_reg_uid_destroy(reg, session->consumer); + } - free(session); + consumer_destroy_output(session->consumer); + consumer_destroy_output(session->tmp_consumer); - rcu_read_unlock(); + free(session); }