X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=liblttng-ust%2Fltt-probes.c;h=8ccb6fab9d2f32c37e2c14fa945adbcb38a9b54e;hb=225b6640cf81f528f6662b502a5cb631e12f0eca;hp=903e05298a7c96a72f081265681d4d3c86ff8c0e;hpb=51c5df09105025dc696ac5c89a819b73cc52b687;p=lttng-ust.git diff --git a/liblttng-ust/ltt-probes.c b/liblttng-ust/ltt-probes.c index 903e0529..8ccb6fab 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,6 +25,8 @@ #include #include #include +#include +#include "tracepoint-internal.h" #include #include #include @@ -26,12 +40,6 @@ */ static CDS_LIST_HEAD(probe_list); -/* - * Wildcard list, containing the active wildcards. - * Protected by ust lock. - */ -static CDS_LIST_HEAD(wildcard_list); - static const struct lttng_probe_desc *find_provider(const char *provider) { @@ -103,7 +111,12 @@ desc_added: * 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: @@ -168,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); } } } @@ -212,35 +219,124 @@ struct lttng_ust_tracepoint_iter * return &entry->tp; } -/* WILDCARDS */ +void ltt_probes_prune_field_list(struct lttng_ust_field_list *list) +{ + struct tp_field_list_entry *list_entry, *tmp; + + cds_list_for_each_entry_safe(list_entry, tmp, &list->head, head) { + cds_list_del(&list_entry->head); + free(list_entry); + } +} /* - * Return wildcard for a given event name if the event name match the - * one of the wildcards. - * Must be called with ust lock held. - * Returns NULL if not present. + * called with UST lock held. */ -struct wildcard_entry *match_wildcard(const char *name) +int ltt_probes_get_field_list(struct lttng_ust_field_list *list) { - struct wildcard_entry *e; - - cds_list_for_each_entry(e, &wildcard_list, list) { - /* If only contain '*' */ - if (strlen(e->name) == 1) - return e; - /* Compare excluding final '*' */ - if (!strncmp(name, e->name, strlen(e->name) - 1)) - return e; + struct lttng_probe_desc *probe_desc; + int i; + + CDS_INIT_LIST_HEAD(&list->head); + cds_list_for_each_entry(probe_desc, &probe_list, head) { + for (i = 0; i < probe_desc->nr_events; i++) { + const struct lttng_event_desc *event_desc = + probe_desc->event_desc[i]; + int j; + + for (j = 0; j < event_desc->nr_fields; j++) { + const struct lttng_event_field *event_field = + &event_desc->fields[j]; + struct tp_field_list_entry *list_entry; + + list_entry = zmalloc(sizeof(*list_entry)); + if (!list_entry) + goto err_nomem; + cds_list_add(&list_entry->head, &list->head); + strncpy(list_entry->field.event_name, + event_desc->name, + LTTNG_UST_SYM_NAME_LEN); + list_entry->field.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; + strncpy(list_entry->field.field_name, + event_field->name, + LTTNG_UST_SYM_NAME_LEN); + list_entry->field.field_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; + switch (event_field->type.atype) { + case atype_integer: + list_entry->field.type = LTTNG_UST_FIELD_INTEGER; + break; + case atype_string: + list_entry->field.type = LTTNG_UST_FIELD_STRING; + break; + case atype_array: + if (event_field->type.u.array.elem_type.atype != atype_integer + || event_field->type.u.array.elem_type.u.basic.integer.encoding == lttng_encode_none) + list_entry->field.type = LTTNG_UST_FIELD_OTHER; + else + list_entry->field.type = LTTNG_UST_FIELD_STRING; + break; + case atype_sequence: + if (event_field->type.u.sequence.elem_type.atype != atype_integer + || event_field->type.u.sequence.elem_type.u.basic.integer.encoding == lttng_encode_none) + list_entry->field.type = LTTNG_UST_FIELD_OTHER; + else + list_entry->field.type = LTTNG_UST_FIELD_STRING; + break; + case atype_float: + list_entry->field.type = LTTNG_UST_FIELD_FLOAT; + break; + case atype_enum: + list_entry->field.type = LTTNG_UST_FIELD_ENUM; + break; + default: + list_entry->field.type = LTTNG_UST_FIELD_OTHER; + } + if (!event_desc->loglevel) { + list_entry->field.loglevel = TRACE_DEFAULT; + } else { + list_entry->field.loglevel = *(*event_desc->loglevel); + } + } + } } - return NULL; + if (cds_list_empty(&list->head)) + list->iter = NULL; + else + list->iter = + cds_list_first_entry(&list->head, + struct tp_field_list_entry, head); + return 0; + +err_nomem: + ltt_probes_prune_field_list(list); + return -ENOMEM; +} + +/* + * Return current iteration position, advance internal iterator to next. + * Return NULL if end of list. + */ +struct lttng_ust_field_iter * + lttng_ust_field_list_get_iter_next(struct lttng_ust_field_list *list) +{ + struct tp_field_list_entry *entry; + + if (!list->iter) + return NULL; + entry = list->iter; + if (entry->head.next == &list->head) + list->iter = NULL; + else + list->iter = cds_list_entry(entry->head.next, + struct tp_field_list_entry, head); + return &entry->field; } /* * marshall all probes/all events and create those that fit the * wildcard. Add them to the events list as created. */ -static -void _probes_create_wildcard_events(struct wildcard_entry *entry, +void ltt_probes_create_wildcard_events(struct wildcard_entry *entry, struct session_wildcard *wildcard) { struct lttng_probe_desc *probe_desc; @@ -259,12 +355,11 @@ void _probes_create_wildcard_events(struct wildcard_entry *entry, && (strlen(entry->name) == 1 || !strncmp(event_desc->name, entry->name, strlen(entry->name) - 1))) { - /* TODO: get value from loglevel. */ - - /* TODO: check if loglevel match */ - //if (event_desc->loglevel - // && (*event_desc->loglevel)->value ...) - match = 1; + if (ltt_loglevel_match(event_desc, + entry->loglevel_type, + entry->loglevel)) { + match = 1; + } } if (match) { struct ltt_event *ev; @@ -277,8 +372,7 @@ void _probes_create_wildcard_events(struct wildcard_entry *entry, sizeof(event_param.name)); /* create event */ ret = ltt_event_create(wildcard->chan, - &event_param, NULL, - &ev); + &event_param, &ev); if (ret) { DBG("Error creating event"); continue; @@ -288,123 +382,6 @@ void _probes_create_wildcard_events(struct wildcard_entry *entry, } } } + lttng_filter_wildcard_link_bytecode(wildcard); } -/* - * Add the wildcard to the wildcard list. Must be called with - * ust lock held. - */ -struct session_wildcard *add_wildcard(const char *name, - struct ltt_channel *chan, - struct lttng_ust_event *event_param) -{ - struct wildcard_entry *e; - struct session_wildcard *sw; - size_t name_len = strlen(name) + 1; - int found = 0; - - /* try to find global wildcard entry */ - cds_list_for_each_entry(e, &wildcard_list, list) { - if (!strncmp(name, e->name, LTTNG_UST_SYM_NAME_LEN - 1)) { - found = 1; - break; - } - } - - if (!found) { - /* - * Create global wildcard entry if not found. Using - * zmalloc here to allocate a variable length element. - * Could cause some memory fragmentation if overused. - */ - e = zmalloc(sizeof(struct wildcard_entry) + name_len); - if (!e) - return ERR_PTR(-ENOMEM); - memcpy(&e->name[0], name, name_len); - cds_list_add(&e->list, &wildcard_list); - CDS_INIT_LIST_HEAD(&e->session_list); - } - - /* session wildcard */ - cds_list_for_each_entry(sw, &e->session_list, session_list) { - if (chan == sw->chan) { - DBG("wildcard %s busy for this channel", name); - return ERR_PTR(-EEXIST); /* Already there */ - } - } - sw = zmalloc(sizeof(struct session_wildcard)); - if (!sw) - return ERR_PTR(-ENOMEM); - sw->chan = chan; - sw->enabled = 1; - memcpy(&sw->event_param, event_param, sizeof(sw->event_param)); - sw->event_param.instrumentation = LTTNG_UST_TRACEPOINT; - CDS_INIT_LIST_HEAD(&sw->events); - cds_list_add(&sw->list, &chan->session->wildcards); - cds_list_add(&sw->session_list, &e->session_list); - sw->entry = e; - _probes_create_wildcard_events(e, sw); - return sw; -} - -/* - * Remove the wildcard from the wildcard list. Must be called with - * ust_lock held. Only called at session teardown. - */ -void _remove_wildcard(struct session_wildcard *wildcard) -{ - struct ltt_event *ev, *tmp; - - /* - * Just remove the events owned (for enable/disable) by this - * wildcard from the list. The session teardown will take care - * of freeing the event memory. - */ - cds_list_for_each_entry_safe(ev, tmp, &wildcard->events, - wildcard_list) { - cds_list_del(&ev->wildcard_list); - } - cds_list_del(&wildcard->session_list); - cds_list_del(&wildcard->list); - if (cds_list_empty(&wildcard->entry->session_list)) { - cds_list_del(&wildcard->entry->list); - free(wildcard->entry); - } - free(wildcard); -} - -int ltt_wildcard_enable(struct session_wildcard *wildcard) -{ - struct ltt_event *ev; - int ret; - - if (wildcard->enabled) - return -EEXIST; - cds_list_for_each_entry(ev, &wildcard->events, wildcard_list) { - ret = ltt_event_enable(ev); - if (ret) { - DBG("Error: enable error.\n"); - return ret; - } - } - wildcard->enabled = 1; - return 0; -} - -int ltt_wildcard_disable(struct session_wildcard *wildcard) -{ - struct ltt_event *ev; - int ret; - - if (!wildcard->enabled) - return -EEXIST; - cds_list_for_each_entry(ev, &wildcard->events, wildcard_list) { - ret = ltt_event_disable(ev); - if (ret) { - DBG("Error: disable error.\n"); - return ret; - } - } - wildcard->enabled = 0; - return 0; -}