Add utils.c and recursive mkdir function

[lttng-tools.git] / ltt-sessiond / kernel-ctl.c

diff --git a/ltt-sessiond/kernel-ctl.c b/ltt-sessiond/kernel-ctl.c
index 2f1864d6495ca8092a4a2744ec5a5c301bac9686..02b01414a4f76296cb4a9b97a2fd7661dbe9aab7 100644 (file)
--- a/ltt-sessiond/kernel-ctl.c
+++ b/ltt-sessiond/kernel-ctl.c
@@ -29,6 +29,68 @@
 #include "libkernelctl.h"
 #include "kernel-ctl.h"
 
+/*
+ *  kernel_add_channel_context
+ *
+ *  Add context on a kernel channel.
+ */
+int kernel_add_channel_context(struct ltt_kernel_channel *chan,
+               struct lttng_kernel_context *ctx)
+{
+       int ret;
+
+       DBG("Adding context to channel %s", chan->channel->name);
+       ret = kernctl_add_context(chan->fd, ctx);
+       if (ret < 0) {
+               perror("add context ioctl");
+               goto error;
+       }
+
+       chan->ctx = malloc(sizeof(struct lttng_kernel_context));
+       if (chan->ctx == NULL) {
+               perror("malloc event context");
+               goto error;
+       }
+
+       memcpy(chan->ctx, ctx, sizeof(struct lttng_kernel_context));
+
+       return 0;
+
+error:
+       return ret;
+}
+
+/*
+ *  kernel_add_event_context
+ *
+ *  Add context on a kernel event.
+ */
+int kernel_add_event_context(struct ltt_kernel_event *event,
+               struct lttng_kernel_context *ctx)
+{
+       int ret;
+
+       DBG("Adding context to event %s", event->event->name);
+       ret = kernctl_add_context(event->fd, ctx);
+       if (ret < 0) {
+               perror("add context ioctl");
+               goto error;
+       }
+
+       event->ctx = malloc(sizeof(struct lttng_kernel_context));
+       if (event->ctx == NULL) {
+               perror("malloc event context");
+               goto error;
+       }
+
+       memcpy(event->ctx, ctx, sizeof(struct lttng_kernel_context));
+
+       return 0;
+
+error:
+       return ret;
+}
+
 /*
  *  kernel_create_session
  *
@@ -124,7 +186,7 @@ error:
  *  Create a kernel event, enable it to the kernel tracer and add it to the
  *  channel event list of the kernel session.
  */
-int kernel_create_event(struct ltt_kernel_channel *channel, struct lttng_event *ev)
+int kernel_create_event(struct lttng_event *ev, struct ltt_kernel_channel *channel)
 {
        int ret;
        struct ltt_kernel_event *event;
@@ -141,7 +203,6 @@ int kernel_create_event(struct ltt_kernel_channel *channel, struct lttng_event *
        }
 
        event->fd = ret;
-       event->enabled = 1;
        /* Prevent fd duplication after execlp() */
        ret = fcntl(event->fd, F_SETFD, FD_CLOEXEC);
        if (ret < 0) {
@@ -161,33 +222,101 @@ error:
 }
 
 /*
- *  kernel_disable_event
+ *  kernel_disable_channel
  *
- *  Disable a kernel event for a specific channel.
+ *  Disable a kernel channel.
  */
-int kernel_disable_event(char *event_name, struct ltt_kernel_channel *channel)
+int kernel_disable_channel(struct ltt_kernel_channel *chan)
 {
        int ret;
-       struct ltt_kernel_event *iter;
 
-       cds_list_for_each_entry(iter, &channel->events_list.head, list) {
-               if (strcmp(iter->event->name, event_name) == 0) {
-                       ret = kernctl_disable(iter->fd);
-                       if (ret < 0) {
-                               perror("disable event ioctl");
-                               goto error;
-                       }
+       ret = kernctl_disable(chan->fd);
+       if (ret < 0) {
+               perror("disable chan ioctl");
+               ret = errno;
+               goto error;
+       }
 
-                       iter->enabled = 0;
-                       DBG("Kernel event %s disabled (fd: %d)", iter->event->name, iter->fd);
-                       break;
-               }
+       chan->enabled = 0;
+       DBG("Kernel channel %s disabled (fd: %d)", chan->channel->name, chan->fd);
+
+       return 0;
+
+error:
+       return ret;
+}
+
+/*
+ *  kernel_enable_channel
+ *
+ *  Enable a kernel channel.
+ */
+int kernel_enable_channel(struct ltt_kernel_channel *chan)
+{
+       int ret;
+
+       ret = kernctl_enable(chan->fd);
+       if (ret < 0) {
+               perror("enable chan ioctl");
+               ret = errno;
+               goto error;
        }
 
+       chan->enabled = 1;
+       DBG("Kernel channel %s enabled (fd: %d)", chan->channel->name, chan->fd);
+
        return 0;
 
 error:
-       return -1;
+       return ret;
+}
+
+/*
+ *  kernel_enable_event
+ *
+ *  Enable a kernel event.
+ */
+int kernel_enable_event(struct ltt_kernel_event *event)
+{
+       int ret;
+
+       ret = kernctl_enable(event->fd);
+       if (ret < 0) {
+               perror("enable event ioctl");
+               goto error;
+       }
+
+       event->enabled = 1;
+       DBG("Kernel event %s enabled (fd: %d)", event->event->name, event->fd);
+
+       return 0;
+
+error:
+       return ret;
+}
+
+/*
+ *  kernel_disable_event
+ *
+ *  Disable a kernel event.
+ */
+int kernel_disable_event(struct ltt_kernel_event *event)
+{
+       int ret;
+
+       ret = kernctl_disable(event->fd);
+       if (ret < 0) {
+               perror("disable event ioctl");
+               goto error;
+       }
+
+       event->enabled = 0;
+       DBG("Kernel event %s disabled (fd: %d)", event->event->name, event->fd);
+
+       return 0;
+
+error:
+       return ret;
 }
 
 /*
@@ -362,8 +491,8 @@ int kernel_open_channel_stream(struct ltt_kernel_channel *channel)
                        perror("fcntl session fd");
                }
 
-               ret = asprintf(&lks->pathname, "%s/trace_%d",
-                               channel->pathname, channel->stream_count);
+               ret = asprintf(&lks->pathname, "%s/%s_%d",
+                               channel->pathname, channel->channel->name, channel->stream_count);
                if (ret < 0) {
                        perror("asprintf kernel create stream");
                        goto error;