Implement $PATH binary searching function for userspace-probe

[lttng-tools.git] / src / bin / lttng-sessiond / trace-kernel.c

diff --git a/src/bin/lttng-sessiond/trace-kernel.c b/src/bin/lttng-sessiond/trace-kernel.c
index 876fda5bbb7fd9ed8d25c0cafdd3c348ec466e7c..f7bb9819746e31265ddd45dbc6a5e3e1eefb9a36 100644 (file)
--- a/src/bin/lttng-sessiond/trace-kernel.c
+++ b/src/bin/lttng-sessiond/trace-kernel.c
@@ -181,7 +181,7 @@ struct ltt_kernel_channel *trace_kernel_create_channel(
                struct lttng_channel *chan)
 {
        struct ltt_kernel_channel *lkc;
-       struct lttng_channel_extended *extended;
+       struct lttng_channel_extended *extended = NULL;
 
        assert(chan);
 
@@ -221,6 +221,7 @@ struct ltt_kernel_channel *trace_kernel_create_channel(
        lkc->stream_count = 0;
        lkc->event_count = 0;
        lkc->enabled = 1;
+       lkc->published_to_notification_thread = false;
        /* Init linked list */
        CDS_INIT_LIST_HEAD(&lkc->events_list.head);
        CDS_INIT_LIST_HEAD(&lkc->stream_list.head);
@@ -256,11 +257,33 @@ struct ltt_kernel_context *trace_kernel_create_context(
        if (ctx) {
                memcpy(&kctx->ctx, ctx, sizeof(kctx->ctx));
        }
+error:
+       return kctx;
+}
+
+/*
+ * Allocate and init a kernel context object from an existing kernel context
+ * object.
+ *
+ * Return the allocated object or NULL on error.
+ */
+struct ltt_kernel_context *trace_kernel_copy_context(
+               struct ltt_kernel_context *kctx)
+{
+       struct ltt_kernel_context *kctx_copy;
+
+       assert(kctx);
+       kctx_copy = zmalloc(sizeof(*kctx_copy));
+       if (!kctx_copy) {
+               PERROR("zmalloc ltt_kernel_context");
+               goto error;
+       }
 
-       CDS_INIT_LIST_HEAD(&kctx->list);
+       memcpy(kctx_copy, kctx, sizeof(*kctx_copy));
+       memset(&kctx_copy->list, 0, sizeof(kctx_copy->list));
 
 error:
-       return kctx;
+       return kctx_copy;
 }
 
 /*
@@ -269,18 +292,22 @@ error:
  *
  * Return pointer to structure or NULL.
  */
-struct ltt_kernel_event *trace_kernel_create_event(struct lttng_event *ev,
-               char *filter_expression, struct lttng_filter_bytecode *filter)
+enum lttng_error_code trace_kernel_create_event(
+               struct lttng_event *ev, char *filter_expression,
+               struct lttng_filter_bytecode *filter,
+               struct ltt_kernel_event **kernel_event)
 {
-       struct ltt_kernel_event *lke;
+       enum lttng_error_code ret;
        struct lttng_kernel_event *attr;
+       struct ltt_kernel_event *local_kernel_event;
 
        assert(ev);
 
-       lke = zmalloc(sizeof(struct ltt_kernel_event));
+       local_kernel_event = zmalloc(sizeof(struct ltt_kernel_event));
        attr = zmalloc(sizeof(struct lttng_kernel_event));
-       if (lke == NULL || attr == NULL) {
+       if (local_kernel_event == NULL || attr == NULL) {
                PERROR("kernel event zmalloc");
+               ret = LTTNG_ERR_NOMEM;
                goto error;
        }
 
@@ -318,6 +345,7 @@ struct ltt_kernel_event *trace_kernel_create_event(struct lttng_event *ev,
                break;
        default:
                ERR("Unknown kernel instrumentation type (%d)", ev->type);
+               ret = LTTNG_ERR_INVALID;
                goto error;
        }
 
@@ -326,20 +354,22 @@ struct ltt_kernel_event *trace_kernel_create_event(struct lttng_event *ev,
        attr->name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
 
        /* Setting up a kernel event */
-       lke->fd = -1;
-       lke->event = attr;
-       lke->enabled = 1;
-       lke->filter_expression = filter_expression;
-       lke->filter = filter;
+       local_kernel_event->fd = -1;
+       local_kernel_event->event = attr;
+       local_kernel_event->enabled = 1;
+       local_kernel_event->filter_expression = filter_expression;
+       local_kernel_event->filter = filter;
+
+       *kernel_event = local_kernel_event;
 
-       return lke;
+       return LTTNG_OK;
 
 error:
        free(filter_expression);
        free(filter);
-       free(lke);
+       free(local_kernel_event);
        free(attr);
-       return NULL;
+       return ret;
 }
 
 /*
@@ -478,7 +508,9 @@ void trace_kernel_destroy_context(struct ltt_kernel_context *ctx)
 {
        assert(ctx);
 
-       cds_list_del(&ctx->list);
+       if (ctx->in_list) {
+               cds_list_del(&ctx->list);
+       }
        free(ctx);
 }
 
@@ -522,10 +554,11 @@ void trace_kernel_destroy_channel(struct ltt_kernel_channel *channel)
        /* Remove from channel list */
        cds_list_del(&channel->list);
 
-       if (notification_thread_handle) {
+       if (notification_thread_handle
+                       && channel->published_to_notification_thread) {
                status = notification_thread_command_remove_channel(
                                notification_thread_handle,
-                               channel->fd, LTTNG_DOMAIN_KERNEL);
+                               channel->key, LTTNG_DOMAIN_KERNEL);
                assert(status == LTTNG_OK);
        }
        free(channel->channel->attr.extended.ptr);