Refactoring: channel enable/disable using common type

[lttng-modules.git] / src / lttng-events.c

diff --git a/src/lttng-events.c b/src/lttng-events.c
index f5c0fa95a5233e604e4312c2b6c773dc6a87960f..bed65028a912fff796d2cf5a00c411780b926ecc 100644 (file)
--- a/src/lttng-events.c
+++ b/src/lttng-events.c
@@ -71,7 +71,7 @@ static void lttng_event_enabler_sync(struct lttng_event_enabler_common *event_en
 
 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_recorder *event);
+static int _lttng_event_recorder_unregister(struct lttng_kernel_event_recorder *event);
 static int _lttng_event_notifier_unregister(struct lttng_kernel_event_notifier *event_notifier);
 static
 int _lttng_event_metadata_statedump(struct lttng_kernel_session *session,
@@ -364,12 +364,12 @@ void lttng_session_destroy(struct lttng_kernel_session *session)
                WARN_ON(ret);
        }
        list_for_each_entry(event_recorder_priv, &session->priv->events, node) {
-               ret = _lttng_event_unregister(event_recorder_priv->pub);
+               ret = _lttng_event_recorder_unregister(event_recorder_priv->pub);
                WARN_ON(ret);
        }
        synchronize_trace();    /* Wait for in-flight events to complete */
        list_for_each_entry(chan_priv, &session->priv->chan, node) {
-               ret = lttng_syscalls_destroy_event(chan_priv->pub);
+               ret = lttng_syscalls_destroy_channel(chan_priv->pub);
                WARN_ON(ret);
        }
        list_for_each_entry_safe(event_recorder_enabler, tmp_event_recorder_enabler,
@@ -578,47 +578,60 @@ end:
        return ret;
 }
 
-int lttng_channel_enable(struct lttng_kernel_channel_buffer *channel)
+static
+bool is_channel_buffer_metadata(struct lttng_kernel_channel_common *channel)
+{
+       struct lttng_kernel_channel_buffer *chan_buf;
+
+       if (channel->type != LTTNG_KERNEL_CHANNEL_TYPE_BUFFER)
+               return false;
+       chan_buf = container_of(channel, struct lttng_kernel_channel_buffer, parent);
+       if (chan_buf->priv->channel_type == METADATA_CHANNEL)
+               return true;
+       return false;
+}
+
+int lttng_channel_enable(struct lttng_kernel_channel_common *channel)
 {
        int ret = 0;
 
        mutex_lock(&sessions_mutex);
-       if (channel->priv->channel_type == METADATA_CHANNEL) {
+       if (is_channel_buffer_metadata(channel)) {
                ret = -EPERM;
                goto end;
        }
-       if (channel->parent.enabled) {
+       if (channel->enabled) {
                ret = -EEXIST;
                goto end;
        }
        /* Set transient enabler state to "enabled" */
-       channel->priv->parent.tstate = 1;
-       lttng_session_sync_event_enablers(channel->parent.session);
+       channel->priv->tstate = 1;
+       lttng_session_sync_event_enablers(channel->session);
        /* Set atomically the state to "enabled" */
-       WRITE_ONCE(channel->parent.enabled, 1);
+       WRITE_ONCE(channel->enabled, 1);
 end:
        mutex_unlock(&sessions_mutex);
        return ret;
 }
 
-int lttng_channel_disable(struct lttng_kernel_channel_buffer *channel)
+int lttng_channel_disable(struct lttng_kernel_channel_common *channel)
 {
        int ret = 0;
 
        mutex_lock(&sessions_mutex);
-       if (channel->priv->channel_type == METADATA_CHANNEL) {
+       if (is_channel_buffer_metadata(channel)) {
                ret = -EPERM;
                goto end;
        }
-       if (!channel->parent.enabled) {
+       if (!channel->enabled) {
                ret = -EEXIST;
                goto end;
        }
        /* Set atomically the state to "disabled" */
-       WRITE_ONCE(channel->parent.enabled, 0);
+       WRITE_ONCE(channel->enabled, 0);
        /* Set transient enabler state to "enabled" */
-       channel->priv->parent.tstate = 0;
-       lttng_session_sync_event_enablers(channel->parent.session);
+       channel->priv->tstate = 0;
+       lttng_session_sync_event_enablers(channel->session);
 end:
        mutex_unlock(&sessions_mutex);
        return ret;
@@ -1425,7 +1438,7 @@ struct lttng_kernel_event_notifier *lttng_event_notifier_create(
 
 /* Only used for tracepoints for now. */
 static
-void register_event(struct lttng_kernel_event_recorder *event_recorder)
+void register_event_recorder(struct lttng_kernel_event_recorder *event_recorder)
 {
        const struct lttng_kernel_event_desc *desc;
        int ret = -EINVAL;
@@ -1442,7 +1455,7 @@ void register_event(struct lttng_kernel_event_recorder *event_recorder)
                break;
 
        case LTTNG_KERNEL_ABI_SYSCALL:
-               ret = lttng_syscall_filter_enable_event(event_recorder->chan, event_recorder);
+               ret = lttng_syscall_filter_enable_event_recorder(event_recorder);
                break;
 
        case LTTNG_KERNEL_ABI_KPROBE:
@@ -1467,7 +1480,7 @@ void register_event(struct lttng_kernel_event_recorder *event_recorder)
 /*
  * Only used internally at session destruction.
  */
-int _lttng_event_unregister(struct lttng_kernel_event_recorder *event_recorder)
+int _lttng_event_recorder_unregister(struct lttng_kernel_event_recorder *event_recorder)
 {
        struct lttng_kernel_event_common_private *event_priv = &event_recorder->priv->parent;
        const struct lttng_kernel_event_desc *desc;
@@ -1495,7 +1508,7 @@ int _lttng_event_unregister(struct lttng_kernel_event_recorder *event_recorder)
                break;
 
        case LTTNG_KERNEL_ABI_SYSCALL:
-               ret = lttng_syscall_filter_disable_event(event_recorder->chan, event_recorder);
+               ret = lttng_syscall_filter_disable_event_recorder(event_recorder);
                break;
 
        case LTTNG_KERNEL_ABI_NOOP:
@@ -2774,9 +2787,9 @@ void lttng_session_sync_event_enablers(struct lttng_kernel_session *session)
                 * state.
                 */
                if (enabled) {
-                       register_event(event_recorder);
+                       register_event_recorder(event_recorder);
                } else {
-                       _lttng_event_unregister(event_recorder);
+                       _lttng_event_recorder_unregister(event_recorder);
                }
 
                /* Check if has enablers without bytecode enabled */