X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;ds=sidebyside;f=src%2Flttng-events.c;h=6512dde8ce1fe2eb3b3f3c5b42e4a0ea5ff46d1d;hb=83006ee0d75381816540c339e5dda7aba72fafa3;hp=b6fbd3470d3bacaed00f070c450085d6d062f89d;hpb=19bef247a29761d0f9ecca993e7088b46456f199;p=lttng-modules.git diff --git a/src/lttng-events.c b/src/lttng-events.c index b6fbd347..6512dde8 100644 --- a/src/lttng-events.c +++ b/src/lttng-events.c @@ -872,13 +872,14 @@ 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) { + struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(&event_enabler->parent); struct lttng_kernel_channel_buffer *chan = event_enabler->chan; struct lttng_kernel_abi_event *event_param = &event_enabler->parent.event_param; enum lttng_kernel_abi_instrumentation itype = event_param->instrumentation; - struct lttng_kernel_session *session = chan->parent.session; struct lttng_kernel_event_recorder *event_recorder; struct lttng_kernel_event_recorder_private *event_recorder_priv; struct lttng_kernel_event_common_private *event_priv; @@ -916,8 +917,7 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l goto type_error; } - head = utils_borrow_hash_table_bucket(session->priv->events_ht.table, - LTTNG_EVENT_HT_SIZE, event_name); + head = utils_borrow_hash_table_bucket(events_ht->table, LTTNG_EVENT_HT_SIZE, 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); @@ -1154,9 +1154,11 @@ 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); struct lttng_event_notifier_group *event_notifier_group = event_enabler->group; struct lttng_kernel_abi_event *event_param = &event_enabler->parent.event_param; uint64_t token = event_enabler->parent.user_token; @@ -1194,8 +1196,7 @@ struct lttng_kernel_event_notifier *_lttng_event_notifier_create(struct lttng_ev goto type_error; } - head = utils_borrow_hash_table_bucket(event_notifier_group->events_ht.table, - LTTNG_EVENT_HT_SIZE, event_name); + head = utils_borrow_hash_table_bucket(events_ht->table, LTTNG_EVENT_HT_SIZE, event_name); lttng_hlist_for_each_entry(event_priv, head, hlist_node) { event_notifier_priv = container_of(event_priv, struct lttng_kernel_event_notifier_private, parent); @@ -1391,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) @@ -1413,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) @@ -2012,36 +2035,85 @@ 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_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_recorder_enabler_as_enabler( - event_enabler); + if (event_enabler->event_param.instrumentation != event->priv->instrumentation) + return false; - 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; + 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; + } } 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_desc_match_event(struct lttng_event_enabler_common *event_enabler, + const struct lttng_kernel_event_desc *desc, + 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 (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 @@ -2061,7 +2133,7 @@ struct lttng_enabler_ref *lttng_enabler_ref( static void lttng_create_tracepoint_event_if_missing(struct lttng_event_recorder_enabler *event_enabler) { - struct lttng_kernel_session *session = event_enabler->chan->parent.session; + struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(&event_enabler->parent); struct lttng_kernel_probe_desc *probe_desc; const struct lttng_kernel_event_desc *desc; int i; @@ -2077,8 +2149,7 @@ 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]; @@ -2089,24 +2160,19 @@ void lttng_create_tracepoint_event_if_missing(struct lttng_event_recorder_enable /* * Check if already created. */ - head = utils_borrow_hash_table_bucket( - session->priv->events_ht.table, LTTNG_EVENT_HT_SIZE, - desc->event_name); + 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->parent, 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->parent, desc); + if (!event) { printk(KERN_INFO "LTTng: Unable to create event %s\n", probe_desc->event_desc[i]->event_name); } @@ -2117,7 +2183,7 @@ 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_notifier_group *event_notifier_group = event_notifier_enabler->group; + 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; @@ -2133,7 +2199,7 @@ void lttng_create_tracepoint_event_notifier_if_missing(struct lttng_event_notifi 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 *event; struct lttng_kernel_event_common_private *event_priv; desc = probe_desc->event_desc[i]; @@ -2144,12 +2210,10 @@ void lttng_create_tracepoint_event_notifier_if_missing(struct lttng_event_notifi /* * Check if already created. */ - head = utils_borrow_hash_table_bucket( - event_notifier_group->events_ht.table, + 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) + if (lttng_event_enabler_desc_match_event(&event_notifier_enabler->parent, desc, event_priv->pub)) found = 1; } if (found) @@ -2158,8 +2222,8 @@ void lttng_create_tracepoint_event_notifier_if_missing(struct lttng_event_notifi /* * 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)) { + event = _lttng_kernel_event_create(&event_notifier_enabler->parent, desc); + if (IS_ERR(event)) { printk(KERN_INFO "Unable to create event_notifier %s\n", probe_desc->event_desc[i]->event_name); } @@ -2234,7 +2298,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)); @@ -2320,7 +2384,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,