X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Flttng-events.c;h=b9452e05f20ad5aeb9c71184570c7bb8e4885943;hb=c8e143808da3085788221089556ecae52afd58a9;hp=039b43e6ffb21f82c9dc864a5c89652aba200a93;hpb=0def91708e136463a7e19e322932844e596a02db;p=lttng-modules.git diff --git a/src/lttng-events.c b/src/lttng-events.c index 039b43e6..b9452e05 100644 --- a/src/lttng-events.c +++ b/src/lttng-events.c @@ -872,6 +872,7 @@ void _lttng_metadata_channel_hangup(struct lttng_metadata_stream *stream) * Supports event creation while tracing session is active. * Needs to be called with sessions mutex held. */ +static struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct lttng_event_recorder_enabler *event_enabler, const struct lttng_kernel_event_desc *event_desc) { @@ -1153,7 +1154,8 @@ full: return ERR_PTR(ret); } -struct lttng_kernel_event_notifier *_lttng_event_notifier_create(struct lttng_event_notifier_enabler *event_enabler, +static +struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_create(struct lttng_event_notifier_enabler *event_enabler, const struct lttng_kernel_event_desc *event_desc) { struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(&event_enabler->parent); @@ -1390,6 +1392,50 @@ type_error: return ERR_PTR(ret); } +struct lttng_kernel_event_common *_lttng_kernel_event_create(struct lttng_event_enabler_common *event_enabler, + const struct lttng_kernel_event_desc *event_desc) +{ + switch (event_enabler->enabler_type) { + case LTTNG_EVENT_ENABLER_TYPE_RECORDER: + { + struct lttng_event_recorder_enabler *event_recorder_enabler = + container_of(event_enabler, struct lttng_event_recorder_enabler, parent); + struct lttng_kernel_event_recorder *event_recorder; + + event_recorder = _lttng_kernel_event_recorder_create(event_recorder_enabler, event_desc); + if (!event_recorder) + return NULL; + return &event_recorder->parent; + } + case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER: + { + struct lttng_event_notifier_enabler *event_notifier_enabler = + container_of(event_enabler, struct lttng_event_notifier_enabler, parent); + struct lttng_kernel_event_notifier *event_notifier; + + event_notifier = _lttng_kernel_event_notifier_create(event_notifier_enabler, event_desc); + if (!event_notifier) + return NULL; + return &event_notifier->parent; + } + default: + return NULL; + } +} + +struct lttng_kernel_event_common *lttng_kernel_event_create(struct lttng_event_enabler_common *event_enabler, + const struct lttng_kernel_event_desc *event_desc) +{ + struct lttng_kernel_event_common *event; + + mutex_lock(&sessions_mutex); + event = _lttng_kernel_event_create(event_enabler, event_desc); + mutex_unlock(&sessions_mutex); + return event; +} + + + int lttng_kernel_counter_read(struct lttng_counter *counter, const size_t *dim_indexes, int32_t cpu, int64_t *val, bool *overflow, bool *underflow) @@ -1412,28 +1458,6 @@ int lttng_kernel_counter_clear(struct lttng_counter *counter, return counter->ops->counter_clear(counter->counter, dim_indexes); } -struct lttng_kernel_event_recorder *lttng_kernel_event_recorder_create(struct lttng_event_recorder_enabler *event_enabler, - const struct lttng_kernel_event_desc *event_desc) -{ - struct lttng_kernel_event_recorder *event; - - mutex_lock(&sessions_mutex); - event = _lttng_kernel_event_recorder_create(event_enabler, event_desc); - mutex_unlock(&sessions_mutex); - return event; -} - -struct lttng_kernel_event_notifier *lttng_event_notifier_create(struct lttng_event_notifier_enabler *event_enabler, - const struct lttng_kernel_event_desc *event_desc) -{ - struct lttng_kernel_event_notifier *event_notifier; - - mutex_lock(&sessions_mutex); - event_notifier = _lttng_event_notifier_create(event_enabler, event_desc); - mutex_unlock(&sessions_mutex); - return event_notifier; -} - /* Only used for tracepoints for now. */ static void register_event(struct lttng_kernel_event_common *event) @@ -1921,7 +1945,8 @@ int lttng_match_enabler_name(const char *desc_name, return 1; } -int lttng_desc_match_enabler(const struct lttng_kernel_event_desc *desc, +static +int lttng_desc_match_enabler_check(const struct lttng_kernel_event_desc *desc, struct lttng_event_enabler_common *enabler) { const char *desc_name, *enabler_name; @@ -2010,37 +2035,97 @@ int lttng_desc_match_enabler(const struct lttng_kernel_event_desc *desc, } } -static -int lttng_event_enabler_match_event(struct lttng_event_recorder_enabler *event_enabler, - struct lttng_kernel_event_recorder *event_recorder) +bool lttng_desc_match_enabler(const struct lttng_kernel_event_desc *desc, + struct lttng_event_enabler_common *enabler) { - struct lttng_event_enabler_common *base_enabler = lttng_event_recorder_enabler_as_enabler( - event_enabler); + int ret; - if (base_enabler->event_param.instrumentation != event_recorder->priv->parent.instrumentation) - return 0; - if (lttng_desc_match_enabler(event_recorder->priv->parent.desc, base_enabler) - && event_recorder->chan == event_enabler->chan) - return 1; - else - return 0; + ret = lttng_desc_match_enabler_check(desc, enabler); + if (ret < 0) { + WARN_ON_ONCE(1); + return false; + } + return ret; } -static -int lttng_event_notifier_enabler_match_event_notifier(struct lttng_event_notifier_enabler *event_notifier_enabler, - struct lttng_kernel_event_notifier *event_notifier) +bool lttng_event_enabler_match_event(struct lttng_event_enabler_common *event_enabler, + struct lttng_kernel_event_common *event) { - struct lttng_event_enabler_common *base_enabler = lttng_event_notifier_enabler_as_enabler( - event_notifier_enabler); + if (event_enabler->event_param.instrumentation != event->priv->instrumentation) + return false; - if (base_enabler->event_param.instrumentation != event_notifier->priv->parent.instrumentation) - return 0; - if (lttng_desc_match_enabler(event_notifier->priv->parent.desc, base_enabler) - && event_notifier->priv->group == event_notifier_enabler->group - && event_notifier->priv->parent.user_token == event_notifier_enabler->parent.user_token) - return 1; - else - return 0; + switch (event_enabler->enabler_type) { + case LTTNG_EVENT_ENABLER_TYPE_RECORDER: + { + struct lttng_event_recorder_enabler *event_recorder_enabler = + container_of(event_enabler, struct lttng_event_recorder_enabler, parent); + struct lttng_kernel_event_recorder *event_recorder = + container_of(event, struct lttng_kernel_event_recorder, parent); + + if (lttng_desc_match_enabler(event->priv->desc, event_enabler) + && event_recorder->chan == event_recorder_enabler->chan) + return true; + else + return false; + } + case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER: + { + struct lttng_event_notifier_enabler *event_notifier_enabler = + container_of(event_enabler, struct lttng_event_notifier_enabler, parent); + struct lttng_kernel_event_notifier *event_notifier = + container_of(event, struct lttng_kernel_event_notifier, parent); + + if (lttng_desc_match_enabler(event->priv->desc, event_enabler) + && event_notifier->priv->group == event_notifier_enabler->group + && event->priv->user_token == event_enabler->user_token) + return true; + else + return false; + } + default: + WARN_ON_ONCE(1); + return false; + } +} + +bool lttng_event_enabler_desc_match_event(struct lttng_event_enabler_common *event_enabler, + const struct lttng_kernel_event_desc *desc, + struct lttng_kernel_event_common *event) +{ + if (event_enabler->event_param.instrumentation != event->priv->instrumentation) + return false; + + switch (event_enabler->enabler_type) { + case LTTNG_EVENT_ENABLER_TYPE_RECORDER: + { + struct lttng_event_recorder_enabler *event_recorder_enabler = + container_of(event_enabler, struct lttng_event_recorder_enabler, parent); + struct lttng_kernel_event_recorder *event_recorder = + container_of(event, struct lttng_kernel_event_recorder, parent); + + if (event->priv->desc == desc && event_recorder->chan == event_recorder_enabler->chan) + return true; + else + return false; + } + case LTTNG_EVENT_ENABLER_TYPE_NOTIFIER: + { + struct lttng_event_notifier_enabler *event_notifier_enabler = + container_of(event_enabler, struct lttng_event_notifier_enabler, parent); + struct lttng_kernel_event_notifier *event_notifier = + container_of(event, struct lttng_kernel_event_notifier, parent); + + if (event->priv->desc == desc + && event_notifier->priv->group == event_notifier_enabler->group + && event->priv->user_token == event_enabler->user_token) + return true; + else + return false; + } + default: + WARN_ON_ONCE(1); + return false; + } } static @@ -2058,13 +2143,13 @@ struct lttng_enabler_ref *lttng_enabler_ref( } static -void lttng_create_tracepoint_event_if_missing(struct lttng_event_recorder_enabler *event_enabler) +void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler_common *event_enabler) { - struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(&event_enabler->parent); + struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(event_enabler); struct lttng_kernel_probe_desc *probe_desc; const struct lttng_kernel_event_desc *desc; - int i; struct list_head *probe_list; + int i; probe_list = lttng_get_probe_list_head(); /* @@ -2076,13 +2161,11 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_recorder_enable for (i = 0; i < probe_desc->nr_events; i++) { int found = 0; struct hlist_head *head; - struct lttng_kernel_event_recorder_private *event_recorder_priv; - struct lttng_kernel_event_recorder *event_recorder; + struct lttng_kernel_event_common *event; struct lttng_kernel_event_common_private *event_priv; desc = probe_desc->event_desc[i]; - if (!lttng_desc_match_enabler(desc, - lttng_event_recorder_enabler_as_enabler(event_enabler))) + if (!lttng_desc_match_enabler(desc, event_enabler)) continue; /* @@ -2090,20 +2173,17 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_recorder_enable */ head = utils_borrow_hash_table_bucket(events_ht->table, LTTNG_EVENT_HT_SIZE, desc->event_name); lttng_hlist_for_each_entry(event_priv, head, hlist_node) { - event_recorder_priv = container_of(event_priv, struct lttng_kernel_event_recorder_private, parent); - if (event_priv->desc == desc - && event_recorder_priv->pub->chan == event_enabler->chan) + if (lttng_event_enabler_desc_match_event(event_enabler, desc, event_priv->pub)) found = 1; } if (found) continue; /* - * We need to create an event for this - * event probe. + * We need to create an event for this event probe. */ - event_recorder = _lttng_kernel_event_recorder_create(event_enabler, desc); - if (!event_recorder) { + event = _lttng_kernel_event_create(event_enabler, desc); + if (!event) { printk(KERN_INFO "LTTng: Unable to create event %s\n", probe_desc->event_desc[i]->event_name); } @@ -2111,58 +2191,6 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_recorder_enable } } -static -void lttng_create_tracepoint_event_notifier_if_missing(struct lttng_event_notifier_enabler *event_notifier_enabler) -{ - struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(&event_notifier_enabler->parent); - struct lttng_kernel_probe_desc *probe_desc; - const struct lttng_kernel_event_desc *desc; - int i; - struct list_head *probe_list; - - probe_list = lttng_get_probe_list_head(); - /* - * For each probe event, if we find that a probe event matches - * our enabler, create an associated lttng_event_notifier if not - * already present. - */ - list_for_each_entry(probe_desc, probe_list, head) { - for (i = 0; i < probe_desc->nr_events; i++) { - int found = 0; - struct hlist_head *head; - struct lttng_kernel_event_notifier *event_notifier; - struct lttng_kernel_event_common_private *event_priv; - - desc = probe_desc->event_desc[i]; - if (!lttng_desc_match_enabler(desc, - lttng_event_notifier_enabler_as_enabler(event_notifier_enabler))) - continue; - - /* - * Check if already created. - */ - head = utils_borrow_hash_table_bucket(events_ht->table, - LTTNG_EVENT_HT_SIZE, desc->event_name); - lttng_hlist_for_each_entry(event_priv, head, hlist_node) { - if (event_priv->desc == desc - && event_priv->user_token == event_notifier_enabler->parent.user_token) - found = 1; - } - if (found) - continue; - - /* - * We need to create a event_notifier for this event probe. - */ - event_notifier = _lttng_event_notifier_create(event_notifier_enabler, desc); - if (IS_ERR(event_notifier)) { - printk(KERN_INFO "Unable to create event_notifier %s\n", - probe_desc->event_desc[i]->event_name); - } - } - } -} - static void lttng_create_syscall_event_if_missing(struct lttng_event_enabler_common *event_enabler) { @@ -2182,7 +2210,7 @@ void lttng_create_event_if_missing(struct lttng_event_recorder_enabler *event_en { switch (event_enabler->parent.event_param.instrumentation) { case LTTNG_KERNEL_ABI_TRACEPOINT: - lttng_create_tracepoint_event_if_missing(event_enabler); + lttng_create_tracepoint_event_if_missing(&event_enabler->parent); break; case LTTNG_KERNEL_ABI_SYSCALL: @@ -2230,7 +2258,7 @@ int lttng_event_enabler_ref_events(struct lttng_event_recorder_enabler *event_en struct lttng_kernel_event_recorder *event_recorder = event_recorder_priv->pub; struct lttng_enabler_ref *enabler_ref; - if (!lttng_event_enabler_match_event(event_enabler, event_recorder)) + if (!lttng_event_enabler_match_event(&event_enabler->parent, &event_recorder->parent)) continue; enabler_ref = lttng_enabler_ref(&event_recorder_priv->parent.enablers_ref_head, lttng_event_recorder_enabler_as_enabler(event_enabler)); @@ -2268,7 +2296,7 @@ void lttng_create_event_notifier_if_missing(struct lttng_event_notifier_enabler { switch (event_notifier_enabler->parent.event_param.instrumentation) { case LTTNG_KERNEL_ABI_TRACEPOINT: - lttng_create_tracepoint_event_notifier_if_missing(event_notifier_enabler); + lttng_create_tracepoint_event_if_missing(&event_notifier_enabler->parent); break; case LTTNG_KERNEL_ABI_SYSCALL: @@ -2316,7 +2344,7 @@ int lttng_event_notifier_enabler_ref_event_notifiers( struct lttng_kernel_event_notifier *event_notifier = event_notifier_priv->pub; struct lttng_enabler_ref *enabler_ref; - if (!lttng_event_notifier_enabler_match_event_notifier(event_notifier_enabler, event_notifier)) + if (!lttng_event_enabler_match_event(&event_notifier_enabler->parent, &event_notifier->parent)) continue; enabler_ref = lttng_enabler_ref(&event_notifier_priv->parent.enablers_ref_head,