X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=ltt-sessiond%2Fkernel-ctl.c;h=0b0fca836bd59b612b3ffbc4eda86f855b2f8954;hb=508f6562a0a21bebcd6412eb0cf8761d359c3ee4;hp=2f1864d6495ca8092a4a2744ec5a5c301bac9686;hpb=e953ef25cbc11fb112aa2e23bf2d44867fe585ed;p=lttng-tools.git diff --git a/ltt-sessiond/kernel-ctl.c b/ltt-sessiond/kernel-ctl.c index 2f1864d64..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; @@ -141,7 +201,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 +220,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; } /* @@ -196,13 +323,13 @@ error: * 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; } @@ -362,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;