X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=ltt-sessiond%2Fkernel-ctl.c;h=2f1864d6495ca8092a4a2744ec5a5c301bac9686;hp=a4d8099f9f773b1ca485dd8cea6c6d08c635e518;hb=e953ef25cbc11fb112aa2e23bf2d44867fe585ed;hpb=540126381ff8f3b1e2b3357329fe105fc0bb5e4c diff --git a/ltt-sessiond/kernel-ctl.c b/ltt-sessiond/kernel-ctl.c index a4d8099f9..2f1864d64 100644 --- a/ltt-sessiond/kernel-ctl.c +++ b/ltt-sessiond/kernel-ctl.c @@ -18,6 +18,7 @@ #define _GNU_SOURCE #include +#include #include #include #include @@ -54,6 +55,13 @@ int kernel_create_session(struct ltt_session *session, int tracer_fd) } lks->fd = ret; + /* Prevent fd duplication after execlp() */ + ret = fcntl(lks->fd, F_SETFD, FD_CLOEXEC); + if (ret < 0) { + perror("fcntl session fd"); + } + + lks->kconsumer_fds_sent = 0; session->kernel_session = lks; session->kern_session_count++; @@ -71,19 +79,19 @@ 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) +int kernel_create_channel(struct ltt_kernel_session *session, struct lttng_channel *chan) { int ret; struct ltt_kernel_channel *lkc; /* Allocate kernel channel */ - lkc = trace_create_kernel_channel(); + lkc = trace_create_kernel_channel(chan); if (lkc == NULL) { goto error; } /* Kernel tracer channel creation */ - ret = kernctl_create_channel(session->fd, lkc->channel); + ret = kernctl_create_channel(session->fd, &lkc->channel->attr); if (ret < 0) { perror("ioctl kernel create channel"); goto error; @@ -91,11 +99,18 @@ int kernel_create_channel(struct ltt_kernel_session *session) /* Setup the channel fd */ lkc->fd = ret; + /* Prevent fd duplication after execlp() */ + ret = fcntl(lkc->fd, F_SETFD, FD_CLOEXEC); + if (ret < 0) { + perror("fcntl session fd"); + } + /* Add channel to session */ cds_list_add(&lkc->list, &session->channel_list.head); session->channel_count++; - DBG("Kernel channel created (fd: %d and path: %s)", lkc->fd, lkc->pathname); + DBG("Kernel channel %s created (fd: %d and path: %s)", + lkc->channel->name, lkc->fd, lkc->pathname); return 0; @@ -104,32 +119,69 @@ error: } /* - * kernel_enable_event + * kernel_create_event * * Create a kernel event, enable it to the kernel tracer and add it to the * channel event list of the kernel session. */ -int kernel_enable_event(struct ltt_kernel_session *session, char *name) +int kernel_create_event(struct ltt_kernel_channel *channel, struct lttng_event *ev) { int ret; - struct ltt_kernel_channel *chan; struct ltt_kernel_event *event; - event = trace_create_kernel_event(name, LTTNG_KERNEL_TRACEPOINTS); + event = trace_create_kernel_event(ev); if (event == NULL) { goto error; } - cds_list_for_each_entry(chan, &session->channel_list.head, list) { - ret = kernctl_create_event(chan->fd, event->event); - if (ret < 0) { - goto error; - } + ret = kernctl_create_event(channel->fd, event->event); + if (ret < 0) { + perror("create event ioctl"); + goto free_event; + } - event->fd = ret; - /* Add event to event list */ - cds_list_add(&event->list, &chan->events_list.head); - DBG("Event %s enabled (fd: %d)", name, event->fd); + event->fd = ret; + event->enabled = 1; + /* Prevent fd duplication after execlp() */ + ret = fcntl(event->fd, F_SETFD, FD_CLOEXEC); + if (ret < 0) { + perror("fcntl session fd"); + } + + /* Add event to event list */ + cds_list_add(&event->list, &channel->events_list.head); + DBG("Event %s created (fd: %d)", ev->name, event->fd); + + return 0; + +free_event: + free(event); +error: + return -1; +} + +/* + * kernel_disable_event + * + * Disable a kernel event for a specific channel. + */ +int kernel_disable_event(char *event_name, struct ltt_kernel_channel *channel) +{ + 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; + } + + iter->enabled = 0; + DBG("Kernel event %s disabled (fd: %d)", iter->event->name, iter->fd); + break; + } } return 0; @@ -156,12 +208,18 @@ int kernel_open_metadata(struct ltt_kernel_session *session) } /* Kernel tracer metadata creation */ - ret = kernctl_open_metadata(session->fd, lkm->conf); + ret = kernctl_open_metadata(session->fd, &lkm->conf->attr); if (ret < 0) { goto error; } lkm->fd = ret; + /* Prevent fd duplication after execlp() */ + ret = fcntl(lkm->fd, F_SETFD, FD_CLOEXEC); + if (ret < 0) { + perror("fcntl session fd"); + } + session->metadata = lkm; DBG("Kernel metadata opened (fd: %d and path: %s)", lkm->fd, lkm->pathname); @@ -183,6 +241,7 @@ int kernel_start_session(struct ltt_kernel_session *session) ret = kernctl_start_session(session->fd); if (ret < 0) { + perror("ioctl start session"); goto error; } @@ -194,6 +253,66 @@ error: return ret; } +/* + * kernel_wait_quiescent + * + * Make a kernel wait to make sure in-flight probe have completed. + */ +void kernel_wait_quiescent(int fd) +{ + int ret; + + DBG("Kernel quiescent wait on %d", fd); + + ret = kernctl_wait_quiescent(fd); + if (ret < 0) { + perror("wait quiescent ioctl"); + ERR("Kernel quiescent wait failed"); + } +} + +/* + * kernel_metadata_flush_buffer + * + * Force flush buffer of metadata. + */ +int kernel_metadata_flush_buffer(int fd) +{ + int ret; + + ret = kernctl_buffer_flush(fd); + if (ret < 0) { + ERR("Fail to flush metadata buffers %d (ret: %d", fd, ret); + } + + return 0; +} + +/* + * kernel_flush_buffer + * + * Force flush buffer for channel. + */ +int kernel_flush_buffer(struct ltt_kernel_channel *channel) +{ + int ret; + struct ltt_kernel_stream *stream; + + DBG("Flush buffer for channel %s", channel->channel->name); + + cds_list_for_each_entry(stream, &channel->stream_list.head, list) { + DBG("Flushing channel stream %d", stream->fd); + ret = kernctl_buffer_flush(stream->fd); + if (ret < 0) { + perror("ioctl"); + ERR("Fail to flush buffer for stream %d (ret: %d)", + stream->fd, ret); + } + } + + return 0; +} + /* * kernel_stop_session * @@ -217,14 +336,14 @@ error: } /* - * kernel_create_channel_stream + * kernel_open_channel_stream * - * Create a stream for a channel, register it to the kernel tracer and add it + * Open stream of channel, register it to the kernel tracer and add it * to the stream list of the channel. * * Return the number of created stream. Else, a negative value. */ -int kernel_create_channel_stream(struct ltt_kernel_channel *channel) +int kernel_open_channel_stream(struct ltt_kernel_channel *channel) { int ret; struct ltt_kernel_stream *lks; @@ -237,6 +356,12 @@ int kernel_create_channel_stream(struct ltt_kernel_channel *channel) } lks->fd = ret; + /* Prevent fd duplication after execlp() */ + ret = fcntl(lks->fd, F_SETFD, FD_CLOEXEC); + if (ret < 0) { + perror("fcntl session fd"); + } + ret = asprintf(&lks->pathname, "%s/trace_%d", channel->pathname, channel->stream_count); if (ret < 0) { @@ -259,11 +384,11 @@ error: } /* - * kernel_create_metadata_stream + * kernel_open_metadata_stream * - * Create the metadata stream and set it to the kernel session. + * Open the metadata stream and set it to the kernel session. */ -int kernel_create_metadata_stream(struct ltt_kernel_session *session) +int kernel_open_metadata_stream(struct ltt_kernel_session *session) { int ret; @@ -275,9 +400,73 @@ int kernel_create_metadata_stream(struct ltt_kernel_session *session) DBG("Kernel metadata stream created (fd: %d)", ret); session->metadata_stream_fd = ret; + /* Prevent fd duplication after execlp() */ + ret = fcntl(session->metadata_stream_fd, F_SETFD, FD_CLOEXEC); + if (ret < 0) { + perror("fcntl session fd"); + } return 0; error: return -1; } + +/* + * kernel_list_events + * + * Get the event list from the kernel tracer and return that list in the CTF + * format. + */ +ssize_t kernel_list_events(int tracer_fd, char **list) +{ + int fd; + char *buf, *line = NULL; + size_t nb, nbmem, total = 0; + ssize_t size; + FILE *fp; + + fd = kernctl_tracepoint_list(tracer_fd); + if (fd < 0) { + perror("kernel tracepoint list"); + goto error; + } + + fp = fdopen(fd, "r"); + if (fp == NULL) { + perror("kernel tracepoint list fdopen"); + goto error; + } + + /* + * Init memory size counter + * See kernel-ctl.h for explanation of this value + */ + nbmem = KERNEL_EVENT_LIST_SIZE; + buf = malloc(nbmem); + + while ((size = getline(&line, &nb, fp)) != -1) { + if (total + size > nbmem) { + DBG("Reallocating event list from %zd to %zd bytes", nbmem, + total + size + KERNEL_EVENT_LIST_SIZE); + /* Adding the default size again */ + nbmem = total + size + KERNEL_EVENT_LIST_SIZE; + buf = realloc(buf, nbmem); + if (buf == NULL) { + perror("realloc list events"); + goto error; + } + } + memcpy(buf + total, line, size); + total += size; + } + + *list = buf; + + DBG("Kernel list events done"); + + return total; + +error: + return -1; +}