Implement loglevels as event and wildcard attributes
[lttng-ust.git] / liblttng-ust / ltt-probes.c
index 35f742a98074b1bb53b8d21de5af907e60d9cf0b..056fad06a161bcad2db548a705fc25e2a14c976b 100644 (file)
  */
 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)
 {
@@ -207,35 +201,11 @@ struct lttng_ust_tracepoint_iter *
        return &entry->tp;
 }
 
-/* WILDCARDS */
-
-/*
- * 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.
- */
-struct wildcard_entry *match_wildcard(const char *name)
-{
-       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;
-       }
-       return NULL;
-}
-
 /*
  * 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;
@@ -254,10 +224,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: check if loglevel match */
-                               //if (event_desc->loglevel
-                               //      && (*event_desc->loglevel) ...)
-                               match = 1;
+                               if (ltt_loglevel_match(event_desc,
+                                       entry->loglevel_type,
+                                               entry->loglevel)) {
+                                       match = 1;
+                               }
                        }
                        if (match) {
                                struct ltt_event *ev;
@@ -283,121 +254,3 @@ void _probes_create_wildcard_events(struct wildcard_entry *entry,
        }
 }
 
-/*
- * 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;
-}
This page took 0.025968 seconds and 4 git commands to generate.