Refactoring: remove unused event_recorder_return
[lttng-modules.git] / src / lttng-events.c
index 08cb66dc49a3fcd00856a5ec3132f2b9c38c034c..bf4df8260bb3bf628b8cd2f08f092d2bb3ed7f06 100644 (file)
@@ -73,9 +73,7 @@ static void _lttng_event_destroy(struct lttng_kernel_event_common *event);
 static void _lttng_channel_destroy(struct lttng_kernel_channel_buffer *chan);
 static int _lttng_event_unregister(struct lttng_kernel_event_common *event);
 static
-int _lttng_event_metadata_statedump(struct lttng_kernel_session *session,
-                                 struct lttng_kernel_channel_buffer *chan,
-                                 struct lttng_kernel_event_recorder *event);
+int _lttng_event_recorder_metadata_statedump(struct lttng_kernel_event_common *event);
 static
 int _lttng_session_metadata_statedump(struct lttng_kernel_session *session);
 static
@@ -970,6 +968,53 @@ void lttng_kernel_event_free(struct lttng_kernel_event_common *event)
        }
 }
 
+static
+int lttng_kernel_event_notifier_clear_error_counter(struct lttng_kernel_event_common *event)
+{
+       switch (event->type) {
+       case LTTNG_KERNEL_EVENT_TYPE_RECORDER:
+               return 0;
+       case LTTNG_KERNEL_EVENT_TYPE_NOTIFIER:
+       {
+               struct lttng_kernel_event_notifier *event_notifier =
+                       container_of(event, struct lttng_kernel_event_notifier, parent);
+               struct lttng_counter *error_counter;
+               struct lttng_event_notifier_group *event_notifier_group = event_notifier->priv->group;
+               size_t dimension_index[1];
+               int ret;
+
+               /*
+                * Clear the error counter bucket. The sessiond keeps track of which
+                * bucket is currently in use. We trust it. The session lock
+                * synchronizes against concurrent creation of the error
+                * counter.
+                */
+               error_counter = event_notifier_group->error_counter;
+               if (!error_counter)
+                       return 0;
+               /*
+                * Check that the index is within the boundary of the counter.
+                */
+               if (event_notifier->priv->error_counter_index >= event_notifier_group->error_counter_len) {
+                       printk(KERN_INFO "LTTng: event_notifier: Error counter index out-of-bound: counter-len=%zu, index=%llu\n",
+                               event_notifier_group->error_counter_len, event_notifier->priv->error_counter_index);
+                       return -EINVAL;
+               }
+
+               dimension_index[0] = event_notifier->priv->error_counter_index;
+               ret = error_counter->ops->counter_clear(error_counter->counter, dimension_index);
+               if (ret) {
+                       printk(KERN_INFO "LTTng: event_notifier: Unable to clear error counter bucket %llu\n",
+                               event_notifier->priv->error_counter_index);
+                       return -EINVAL;
+               }
+               return 0;
+       }
+       default:
+               return -EINVAL;
+       }
+}
+
 /*
  * Supports event creation while tracing session is active.
  * Needs to be called with sessions mutex held.
@@ -979,12 +1024,12 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
                                const struct lttng_kernel_event_desc *event_desc)
 {
        struct lttng_event_ht *events_ht = lttng_get_event_ht_from_enabler(&event_enabler->parent);
+       struct list_head *event_list_head = lttng_get_event_list_head_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_event_common_private *event_priv;
        struct lttng_kernel_event_common *event;
-       struct lttng_kernel_event_recorder_private *event_recorder_priv;
        struct lttng_kernel_event_recorder *event_recorder;
        const char *event_name;
        struct hlist_head *head;
@@ -1022,12 +1067,7 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
 
        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);
-
-               WARN_ON_ONCE(!event_priv->desc);
-               if (!strncmp(event_priv->desc->event_name, event_name,
-                                       LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1)
-                               && chan == event_recorder_priv->pub->chan) {
+               if (lttng_event_enabler_event_name_match_event(&event_enabler->parent, event_name, event_priv->pub)) {
                        ret = -EEXIST;
                        goto exist;
                }
@@ -1082,7 +1122,6 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
        case LTTNG_KERNEL_ABI_KRETPROBE:
        {
                struct lttng_kernel_event_common *event_return;
-               struct lttng_kernel_event_recorder *event_recorder_return;
 
                /* kretprobe defines 2 events */
                /*
@@ -1097,7 +1136,6 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
                        ret = -ENOMEM;
                        goto alloc_error;
                }
-               event_recorder_return = container_of(event_return, struct lttng_kernel_event_recorder, parent);
 
                event_return->enabled = 0;
                event_return->priv->registered = 1;
@@ -1121,7 +1159,7 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
                WARN_ON_ONCE(!ret);
                ret = try_module_get(event_return->priv->desc->owner);
                WARN_ON_ONCE(!ret);
-               ret = _lttng_event_metadata_statedump(chan->parent.session, chan, event_recorder_return);
+               ret = _lttng_event_recorder_metadata_statedump(event_return);
                WARN_ON_ONCE(ret > 0);
                if (ret) {
                        lttng_kernel_event_free(event_return);
@@ -1129,7 +1167,7 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
                        module_put(event->priv->desc->owner);
                        goto statedump_error;
                }
-               list_add(&event_return->priv->node, &chan->parent.session->priv->events);
+               list_add(&event_return->priv->node, event_list_head);
                break;
        }
 
@@ -1201,13 +1239,13 @@ struct lttng_kernel_event_recorder *_lttng_kernel_event_recorder_create(struct l
                ret = -EINVAL;
                goto register_error;
        }
-       ret = _lttng_event_metadata_statedump(chan->parent.session, chan, event_recorder);
+       ret = _lttng_event_recorder_metadata_statedump(event);
        WARN_ON_ONCE(ret > 0);
        if (ret) {
                goto statedump_error;
        }
        hlist_add_head(&event->priv->hlist_node, head);
-       list_add(&event->priv->node, &chan->parent.session->priv->events);
+       list_add(&event->priv->node, event_list_head);
        return event_recorder;
 
 statedump_error:
@@ -1226,15 +1264,12 @@ struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_create(struct l
                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 list_head *event_list_head = lttng_get_event_list_head_from_enabler(&event_enabler->parent);
        struct lttng_kernel_abi_event *event_param = &event_enabler->parent.event_param;
-       uint64_t token = event_enabler->parent.user_token;
        enum lttng_kernel_abi_instrumentation itype = event_param->instrumentation;
        struct lttng_kernel_event_common_private *event_priv;
        struct lttng_kernel_event_common *event;
-       struct lttng_kernel_event_notifier_private *event_notifier_priv;
        struct lttng_kernel_event_notifier *event_notifier;
-       struct lttng_counter *error_counter;
        const char *event_name;
        struct hlist_head *head;
        int ret;
@@ -1266,13 +1301,7 @@ struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_create(struct l
 
        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);
-
-               WARN_ON_ONCE(!event_priv->desc);
-               if (!strncmp(event_priv->desc->event_name, event_name,
-                                       LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1)
-                               && event_notifier_group == event_notifier_priv->group
-                               && token == event_priv->user_token) {
+               if (lttng_event_enabler_event_name_match_event(&event_enabler->parent, event_name, event_priv->pub)) {
                        ret = -EEXIST;
                        goto exist;
                }
@@ -1396,38 +1425,12 @@ struct lttng_kernel_event_notifier *_lttng_kernel_event_notifier_create(struct l
                goto register_error;
        }
 
-       list_add(&event->priv->node, &event_notifier_group->event_notifiers_head);
+       list_add(&event->priv->node, event_list_head);
        hlist_add_head(&event->priv->hlist_node, head);
 
-       /*
-        * Clear the error counter bucket. The sessiond keeps track of which
-        * bucket is currently in use. We trust it. The session lock
-        * synchronizes against concurrent creation of the error
-        * counter.
-        */
-       error_counter = event_notifier_group->error_counter;
-       if (error_counter) {
-               size_t dimension_index[1];
-
-               /*
-                * Check that the index is within the boundary of the counter.
-                */
-               if (event_notifier->priv->error_counter_index >= event_notifier_group->error_counter_len) {
-                       printk(KERN_INFO "LTTng: event_notifier: Error counter index out-of-bound: counter-len=%zu, index=%llu\n",
-                               event_notifier_group->error_counter_len, event_notifier->priv->error_counter_index);
-                       ret = -EINVAL;
-                       goto register_error;
-               }
-
-               dimension_index[0] = event_notifier->priv->error_counter_index;
-               ret = error_counter->ops->counter_clear(error_counter->counter, dimension_index);
-               if (ret) {
-                       printk(KERN_INFO "LTTng: event_notifier: Unable to clear error counter bucket %llu\n",
-                               event_notifier->priv->error_counter_index);
-                       goto register_error;
-               }
-       }
-
+       ret = lttng_kernel_event_notifier_clear_error_counter(event);
+       if (ret)
+               goto register_error;
        return event_notifier;
 
 register_error:
@@ -2174,6 +2177,47 @@ bool lttng_event_enabler_desc_match_event(struct lttng_event_enabler_common *eve
        }
 }
 
+bool lttng_event_enabler_event_name_match_event(struct lttng_event_enabler_common *event_enabler,
+               const char *event_name,
+               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 (!strncmp(event->priv->desc->event_name, event_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1)
+                               && 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 (!strncmp(event->priv->desc->event_name, event_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1)
+                               && 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
 struct lttng_enabler_ref *lttng_enabler_ref(
                struct list_head *enablers_ref_list,
@@ -3616,12 +3660,19 @@ int _lttng_fields_metadata_statedump(struct lttng_kernel_session *session,
  * transaction.
  */
 static
-int _lttng_event_metadata_statedump(struct lttng_kernel_session *session,
-                                 struct lttng_kernel_channel_buffer *chan,
-                                 struct lttng_kernel_event_recorder *event_recorder)
+int _lttng_event_recorder_metadata_statedump(struct lttng_kernel_event_common *event)
 {
+       struct lttng_kernel_event_recorder *event_recorder;
+       struct lttng_kernel_channel_buffer *chan;
+       struct lttng_kernel_session *session;
        int ret = 0;
 
+       if (event->type != LTTNG_KERNEL_EVENT_TYPE_RECORDER)
+               return 0;
+       event_recorder = container_of(event, struct lttng_kernel_event_recorder, parent);
+       chan = event_recorder->chan;
+       session = chan->parent.session;
+
        if (event_recorder->priv->metadata_dumped || !LTTNG_READ_ONCE(session->active))
                return 0;
        if (chan->priv->channel_type == METADATA_CHANNEL)
@@ -4076,8 +4127,7 @@ skip_session:
        }
 
        list_for_each_entry(event_recorder_priv, &session->priv->events, parent.node) {
-               ret = _lttng_event_metadata_statedump(session, event_recorder_priv->pub->chan,
-                               event_recorder_priv->pub);
+               ret = _lttng_event_recorder_metadata_statedump(&event_recorder_priv->pub->parent);
                if (ret)
                        goto end;
        }
This page took 0.027319 seconds and 4 git commands to generate.