X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust%2Fltt-probes.c;h=15c83873f6ad25ab038b638b5ff2ec8243f2f793;hb=7a673d9947d11a37d08be89a5c157afdfd377f9f;hp=25eb3f608c95cb6cf1e3f8708ca2133c7d538c7e;hpb=7ee3cc563d8512f73f9f7379510ebf1673eb88a8;p=lttng-ust.git diff --git a/liblttng-ust/ltt-probes.c b/liblttng-ust/ltt-probes.c index 25eb3f60..15c83873 100644 --- a/liblttng-ust/ltt-probes.c +++ b/liblttng-ust/ltt-probes.c @@ -1,11 +1,23 @@ /* * ltt-probes.c * - * Copyright 2010 (c) - Mathieu Desnoyers - * * Holds LTTng probes registry. * - * Dual LGPL v2.1/GPL v2 license. + * Copyright 2010-2012 (c) - Mathieu Desnoyers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; only + * version 2.1 of the License. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include @@ -13,8 +25,11 @@ #include #include #include +#include +#include "tracepoint-internal.h" #include #include +#include #include "ltt-tracer-core.h" #include "jhash.h" @@ -25,14 +40,6 @@ */ static CDS_LIST_HEAD(probe_list); -/* - * Loglevel hash table, containing the active loglevels. - * Protected by ust lock. - */ -#define LOGLEVEL_HASH_BITS 6 -#define LOGLEVEL_TABLE_SIZE (1 << LOGLEVEL_HASH_BITS) -static struct cds_hlist_head loglevel_table[LOGLEVEL_TABLE_SIZE]; - static const struct lttng_probe_desc *find_provider(const char *provider) { @@ -53,7 +60,8 @@ const struct lttng_event_desc *find_event(const char *name) cds_list_for_each_entry(probe_desc, &probe_list, head) { for (i = 0; i < probe_desc->nr_events; i++) { - if (!strcmp(probe_desc->event_desc[i]->name, name)) + if (!strncmp(probe_desc->event_desc[i]->name, name, + LTTNG_UST_SYM_NAME_LEN - 1)) return probe_desc->event_desc[i]; } } @@ -97,12 +105,18 @@ int ltt_probe_register(struct lttng_probe_desc *desc) /* We should be added at the head of the list */ cds_list_add(&desc->head, &probe_list); desc_added: - + DBG("just registered probe %s containing %u events", + desc->provider, desc->nr_events); /* * fix the events awaiting probe load. */ for (i = 0; i < desc->nr_events; i++) { - ret = pending_probe_fix_events(desc->event_desc[i]); + const struct lttng_event_desc *ed; + + ed = desc->event_desc[i]; + DBG("Registered event probe \"%s\" with signature \"%s\"", + ed->name, ed->signature); + ret = pending_probe_fix_events(ed); assert(!ret); } end: @@ -114,6 +128,7 @@ void ltt_probe_unregister(struct lttng_probe_desc *desc) { ust_lock(); cds_list_del(&desc->head); + DBG("just unregistered probe %s", desc->provider); ust_unlock(); } @@ -166,15 +181,9 @@ int ltt_probes_get_event_list(struct lttng_ust_tracepoint_list *list) LTTNG_UST_SYM_NAME_LEN); list_entry->tp.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; if (!probe_desc->event_desc[i]->loglevel) { - list_entry->tp.loglevel[0] = '\0'; - list_entry->tp.loglevel_value = 0; + list_entry->tp.loglevel = TRACE_DEFAULT; } else { - strncpy(list_entry->tp.loglevel, - (*probe_desc->event_desc[i]->loglevel)->identifier, - LTTNG_UST_SYM_NAME_LEN); - list_entry->tp.loglevel[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; - list_entry->tp.loglevel_value = - (*probe_desc->event_desc[i]->loglevel)->value; + list_entry->tp.loglevel = *(*probe_desc->event_desc[i]->loglevel); } } } @@ -210,33 +219,12 @@ struct lttng_ust_tracepoint_iter * return &entry->tp; } -/* - * Get loglevel if the loglevel is present in the loglevel hash table. - * Must be called with ust lock held. - * Returns NULL if not present. - */ -struct loglevel_entry *get_loglevel(const char *name) -{ - struct cds_hlist_head *head; - struct cds_hlist_node *node; - struct loglevel_entry *e; - uint32_t hash = jhash(name, strlen(name), 0); - - head = &loglevel_table[hash & (LOGLEVEL_TABLE_SIZE - 1)]; - cds_hlist_for_each_entry(e, node, head, hlist) { - if (!strcmp(name, e->name)) - return e; - } - return NULL; -} - /* * marshall all probes/all events and create those that fit the - * loglevel. Add them to the events list as created. + * wildcard. Add them to the events list as created. */ -static -void _probes_create_loglevel_events(struct loglevel_entry *entry, - struct session_loglevel *loglevel) +void ltt_probes_create_wildcard_events(struct wildcard_entry *entry, + struct session_wildcard *wildcard) { struct lttng_probe_desc *probe_desc; struct lttng_ust_event event_param; @@ -244,154 +232,44 @@ void _probes_create_loglevel_events(struct loglevel_entry *entry, cds_list_for_each_entry(probe_desc, &probe_list, head) { for (i = 0; i < probe_desc->nr_events; i++) { - const struct tracepoint_loglevel_entry *ev_ll; const struct lttng_event_desc *event_desc; + int match = 0; event_desc = probe_desc->event_desc[i]; - if (!(event_desc->loglevel)) - continue; - ev_ll = *event_desc->loglevel; - if (!strcmp(ev_ll->identifier, entry->name)) { + /* compare excluding final '*' */ + assert(strlen(entry->name) > 0); + if (strcmp(event_desc->name, "lttng_ust:metadata") + && (strlen(entry->name) == 1 + || !strncmp(event_desc->name, entry->name, + strlen(entry->name) - 1))) { + if (ltt_loglevel_match(event_desc, + entry->loglevel_type, + entry->loglevel)) { + match = 1; + } + } + if (match) { struct ltt_event *ev; int ret; - memcpy(&event_param, &loglevel->event_param, + memcpy(&event_param, &wildcard->event_param, sizeof(event_param)); - memcpy(event_param.name, + strncpy(event_param.name, event_desc->name, sizeof(event_param.name)); + event_param.name[sizeof(event_param.name) - 1] = '\0'; /* create event */ - ret = ltt_event_create(loglevel->chan, + ret = ltt_event_create(wildcard->chan, &event_param, NULL, &ev); if (ret) { DBG("Error creating event"); continue; } - cds_list_add(&ev->loglevel_list, - &loglevel->events); + cds_list_add(&ev->wildcard_list, + &wildcard->events); } } } } -/* - * Add the loglevel to the loglevel hash table. Must be called with - * ust lock held. - */ -struct session_loglevel *add_loglevel(const char *name, - struct ltt_channel *chan, - struct lttng_ust_event *event_param) -{ - struct cds_hlist_head *head; - struct cds_hlist_node *node; - struct loglevel_entry *e; - struct session_loglevel *sl; - size_t name_len = strlen(name) + 1; - uint32_t hash = jhash(name, name_len-1, 0); - int found = 0; - - /* loglevel entry */ - head = &loglevel_table[hash & (LOGLEVEL_TABLE_SIZE - 1)]; - cds_hlist_for_each_entry(e, node, head, hlist) { - if (!strcmp(name, e->name)) { - found = 1; - break; - } - } - - if (!found) { - /* - * Using zmalloc here to allocate a variable length element. Could - * cause some memory fragmentation if overused. - */ - e = zmalloc(sizeof(struct loglevel_entry) + name_len); - if (!e) - return ERR_PTR(-ENOMEM); - memcpy(&e->name[0], name, name_len); - cds_hlist_add_head(&e->hlist, head); - CDS_INIT_LIST_HEAD(&e->session_list); - } - - /* session loglevel */ - cds_list_for_each_entry(sl, &e->session_list, session_list) { - if (chan == sl->chan) { - DBG("loglevel %s busy for this channel", name); - return ERR_PTR(-EEXIST); /* Already there */ - } - } - sl = zmalloc(sizeof(struct session_loglevel)); - if (!sl) - return ERR_PTR(-ENOMEM); - sl->chan = chan; - sl->enabled = 1; - memcpy(&sl->event_param, event_param, sizeof(sl->event_param)); - sl->event_param.instrumentation = LTTNG_UST_TRACEPOINT; - CDS_INIT_LIST_HEAD(&sl->events); - cds_list_add(&sl->list, &chan->session->loglevels); - cds_list_add(&sl->session_list, &e->session_list); - sl->entry = e; - _probes_create_loglevel_events(e, sl); - return sl; -} - -/* - * Remove the loglevel from the loglevel hash table. Must be called with - * ust_lock held. Only called at session teardown. - */ -void _remove_loglevel(struct session_loglevel *loglevel) -{ - struct ltt_event *ev, *tmp; - - /* - * Just remove the events owned (for enable/disable) by this - * loglevel from the list. The session teardown will take care - * of freeing the event memory. - */ - cds_list_for_each_entry_safe(ev, tmp, &loglevel->events, list) { - cds_list_del(&ev->list); - } - cds_list_del(&loglevel->session_list); - cds_list_del(&loglevel->list); - if (cds_list_empty(&loglevel->entry->session_list)) { - cds_hlist_del(&loglevel->entry->hlist); - free(loglevel->entry); - } - free(loglevel); -} - -int ltt_loglevel_enable(struct session_loglevel *loglevel) -{ - struct ltt_event *ev; - int ret; - - if (loglevel->enabled) - return -EEXIST; - cds_list_for_each_entry(ev, &loglevel->events, list) { - ret = ltt_event_enable(ev); - if (ret) { - DBG("Error: enable error.\n"); - return ret; - } - } - loglevel->enabled = 1; - return 0; -} - -int ltt_loglevel_disable(struct session_loglevel *loglevel) -{ - struct ltt_event *ev; - int ret; - - if (!loglevel->enabled) - return -EEXIST; - cds_list_for_each_entry(ev, &loglevel->events, list) { - ret = ltt_event_disable(ev); - if (ret) { - DBG("Error: disable error.\n"); - return ret; - } - } - loglevel->enabled = 0; - return 0; -}