X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=ltt-sessiond%2Fkernel-ctl.c;h=0b0fca836bd59b612b3ffbc4eda86f855b2f8954;hb=a2fb29a51133de95720cc389121f403c21b25b8f;hp=3925c6ba5afc8e17f193dea1b497c7291a5ac52f;hpb=7b3958902a08e7d96d388614f2726ad8a6fc9df2;p=lttng-tools.git diff --git a/ltt-sessiond/kernel-ctl.c b/ltt-sessiond/kernel-ctl.c index 3925c6ba5..0b0fca836 100644 --- a/ltt-sessiond/kernel-ctl.c +++ b/ltt-sessiond/kernel-ctl.c @@ -25,10 +25,71 @@ #include #include "lttngerr.h" -#include "ltt-sessiond.h" #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 * @@ -63,7 +124,6 @@ int kernel_create_session(struct ltt_session *session, int tracer_fd) lks->kconsumer_fds_sent = 0; session->kernel_session = lks; - session->kern_session_count++; DBG("Kernel session created (fd: %d)", lks->fd); @@ -79,13 +139,13 @@ error: * Create a kernel channel, register it to the kernel tracer and add it to the * kernel session. */ -int kernel_create_channel(struct ltt_kernel_session *session, struct lttng_channel *chan) +int kernel_create_channel(struct ltt_kernel_session *session, struct lttng_channel *chan, char *path) { int ret; struct ltt_kernel_channel *lkc; /* Allocate kernel channel */ - lkc = trace_create_kernel_channel(chan); + lkc = trace_create_kernel_channel(chan, path); if (lkc == NULL) { goto error; } @@ -124,7 +184,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; @@ -136,8 +196,8 @@ int kernel_create_event(struct ltt_kernel_channel *channel, struct lttng_event * ret = kernctl_create_event(channel->fd, event->event); if (ret < 0) { - ERR("Unable to enable event %s for channel %s", ev->name, channel->channel->name); - goto error; + perror("create event ioctl"); + goto free_event; } event->fd = ret; @@ -149,27 +209,127 @@ int kernel_create_event(struct ltt_kernel_channel *channel, struct lttng_event * /* Add event to event list */ cds_list_add(&event->list, &channel->events_list.head); - DBG("Event %s enabled (fd: %d)", ev->name, event->fd); + DBG("Event %s created (fd: %d)", ev->name, event->fd); return 0; +free_event: + free(event); error: return -1; } +/* + * kernel_disable_channel + * + * Disable a kernel channel. + */ +int kernel_disable_channel(struct ltt_kernel_channel *chan) +{ + int ret; + + ret = kernctl_disable(chan->fd); + if (ret < 0) { + perror("disable chan ioctl"); + ret = errno; + goto error; + } + + 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 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; +} + /* * kernel_open_metadata * * Create kernel metadata, open from the kernel tracer and add it to the * kernel session. */ -int kernel_open_metadata(struct ltt_kernel_session *session) +int kernel_open_metadata(struct ltt_kernel_session *session, char *path) { int ret; struct ltt_kernel_metadata *lkm; /* Allocate kernel metadata */ - lkm = trace_create_kernel_metadata(); + lkm = trace_create_kernel_metadata(path); if (lkm == NULL) { goto error; } @@ -329,8 +489,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;