X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fkernel.c;h=6fce7d84fd01644f99e30b091f61f0edc4890cc2;hp=2ebd5acbdd79dec5f7441362ccf89bd925c74c95;hb=a4b92340642035d1eafeb1eead0ad01f64d2007d;hpb=990570edd474b304d4c935d82be6201d872025e4 diff --git a/src/bin/lttng-sessiond/kernel.c b/src/bin/lttng-sessiond/kernel.c index 2ebd5acbd..6fce7d84f 100644 --- a/src/bin/lttng-sessiond/kernel.c +++ b/src/bin/lttng-sessiond/kernel.c @@ -1,19 +1,18 @@ /* * Copyright (C) 2011 - David Goulet * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; only version 2 - * of the License. + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2 only, + * as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #define _GNU_SOURCE @@ -24,11 +23,12 @@ #include #include -#include -#include #include +#include +#include #include "kernel.h" +#include "kern-modules.h" /* * Add context on a kernel channel. @@ -42,7 +42,7 @@ int kernel_add_channel_context(struct ltt_kernel_channel *chan, ret = kernctl_add_context(chan->fd, ctx); if (ret < 0) { if (errno != EEXIST) { - perror("add context ioctl"); + PERROR("add context ioctl"); } else { /* If EEXIST, we just ignore the error */ ret = 0; @@ -52,7 +52,7 @@ int kernel_add_channel_context(struct ltt_kernel_channel *chan, chan->ctx = zmalloc(sizeof(struct lttng_kernel_context)); if (chan->ctx == NULL) { - perror("zmalloc event context"); + PERROR("zmalloc event context"); goto error; } @@ -75,13 +75,13 @@ int kernel_add_event_context(struct ltt_kernel_event *event, DBG("Adding context to event %s", event->event->name); ret = kernctl_add_context(event->fd, ctx); if (ret < 0) { - perror("add context ioctl"); + PERROR("add context ioctl"); goto error; } event->ctx = zmalloc(sizeof(struct lttng_kernel_context)); if (event->ctx == NULL) { - perror("zmalloc event context"); + PERROR("zmalloc event context"); goto error; } @@ -112,7 +112,7 @@ int kernel_create_session(struct ltt_session *session, int tracer_fd) /* Kernel tracer session creation */ ret = kernctl_create_session(tracer_fd); if (ret < 0) { - perror("ioctl kernel create session"); + PERROR("ioctl kernel create session"); goto error; } @@ -120,7 +120,7 @@ int kernel_create_session(struct ltt_session *session, int tracer_fd) /* Prevent fd duplication after execlp() */ ret = fcntl(lks->fd, F_SETFD, FD_CLOEXEC); if (ret < 0) { - perror("fcntl session fd"); + PERROR("fcntl session fd"); } lks->consumer_fds_sent = 0; @@ -150,10 +150,16 @@ int kernel_create_channel(struct ltt_kernel_session *session, goto error; } + DBG3("Kernel create channel %s in %s with attr: %d, %zu, %zu, %u, %u, %d", + chan->name, path, lkc->channel->attr.overwrite, + lkc->channel->attr.subbuf_size, lkc->channel->attr.num_subbuf, + lkc->channel->attr.switch_timer_interval, lkc->channel->attr.read_timer_interval, + lkc->channel->attr.output); + /* Kernel tracer channel creation */ ret = kernctl_create_channel(session->fd, &lkc->channel->attr); if (ret < 0) { - perror("ioctl kernel create channel"); + PERROR("ioctl kernel create channel"); goto error; } @@ -162,15 +168,14 @@ int kernel_create_channel(struct ltt_kernel_session *session, /* Prevent fd duplication after execlp() */ ret = fcntl(lkc->fd, F_SETFD, FD_CLOEXEC); if (ret < 0) { - perror("fcntl session fd"); + PERROR("fcntl session fd"); } /* Add channel to session */ cds_list_add(&lkc->list, &session->channel_list.head); session->channel_count++; - DBG("Kernel channel %s created (fd: %d and path: %s)", - lkc->channel->name, lkc->fd, lkc->pathname); + DBG("Kernel channel %s created (fd: %d)", lkc->channel->name, lkc->fd); return 0; @@ -196,7 +201,13 @@ int kernel_create_event(struct lttng_event *ev, ret = kernctl_create_event(channel->fd, event->event); if (ret < 0) { - if (errno != EEXIST) { + switch (errno) { + case EEXIST: + break; + case ENOSYS: + WARN("Event type not implemented"); + break; + default: PERROR("create event ioctl"); } ret = -errno; @@ -204,28 +215,32 @@ int kernel_create_event(struct lttng_event *ev, } /* - * LTTNG_KERNEL_SYSCALL event creation will return 0 on success. However - * this FD must not be added to the event list. + * LTTNG_KERNEL_SYSCALL event creation will return 0 on success. */ if (ret == 0 && event->event->instrumentation == LTTNG_KERNEL_SYSCALL) { DBG2("Kernel event syscall creation success"); - goto end; + /* + * We use fd == -1 to ensure that we never trigger a close of fd + * 0. + */ + event->fd = -1; + goto add_list; } event->fd = ret; /* Prevent fd duplication after execlp() */ ret = fcntl(event->fd, F_SETFD, FD_CLOEXEC); if (ret < 0) { - perror("fcntl session fd"); + PERROR("fcntl session fd"); } +add_list: /* Add event to event list */ cds_list_add(&event->list, &channel->events_list.head); channel->event_count++; DBG("Event %s created (fd: %d)", ev->name, event->fd); -end: return 0; free_event: @@ -243,7 +258,7 @@ int kernel_disable_channel(struct ltt_kernel_channel *chan) ret = kernctl_disable(chan->fd); if (ret < 0) { - perror("disable chan ioctl"); + PERROR("disable chan ioctl"); ret = errno; goto error; } @@ -266,7 +281,7 @@ int kernel_enable_channel(struct ltt_kernel_channel *chan) ret = kernctl_enable(chan->fd); if (ret < 0 && errno != EEXIST) { - perror("Enable kernel chan"); + PERROR("Enable kernel chan"); goto error; } @@ -287,8 +302,15 @@ int kernel_enable_event(struct ltt_kernel_event *event) int ret; ret = kernctl_enable(event->fd); - if (ret < 0 && errno != EEXIST) { - perror("enable kernel event"); + if (ret < 0) { + switch (errno) { + case EEXIST: + ret = LTTCOMM_KERN_EVENT_EXIST; + break; + default: + PERROR("enable kernel event"); + break; + } goto error; } @@ -309,8 +331,15 @@ int kernel_disable_event(struct ltt_kernel_event *event) int ret; ret = kernctl_disable(event->fd); - if (ret < 0 && errno != EEXIST) { - perror("disable kernel event"); + if (ret < 0) { + switch (errno) { + case EEXIST: + ret = LTTCOMM_KERN_EVENT_EXIST; + break; + default: + PERROR("disable kernel event"); + break; + } goto error; } @@ -327,13 +356,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, char *path) +int kernel_open_metadata(struct ltt_kernel_session *session) { int ret; struct ltt_kernel_metadata *lkm; /* Allocate kernel metadata */ - lkm = trace_kernel_create_metadata(path); + lkm = trace_kernel_create_metadata(); if (lkm == NULL) { goto error; } @@ -348,12 +377,12 @@ int kernel_open_metadata(struct ltt_kernel_session *session, char *path) /* Prevent fd duplication after execlp() */ ret = fcntl(lkm->fd, F_SETFD, FD_CLOEXEC); if (ret < 0) { - perror("fcntl session fd"); + PERROR("fcntl session fd"); } session->metadata = lkm; - DBG("Kernel metadata opened (fd: %d and path: %s)", lkm->fd, lkm->pathname); + DBG("Kernel metadata opened (fd: %d)", lkm->fd); return 0; @@ -370,7 +399,7 @@ int kernel_start_session(struct ltt_kernel_session *session) ret = kernctl_start_session(session->fd); if (ret < 0) { - perror("ioctl start session"); + PERROR("ioctl start session"); goto error; } @@ -393,7 +422,7 @@ void kernel_wait_quiescent(int fd) ret = kernctl_wait_quiescent(fd); if (ret < 0) { - perror("wait quiescent ioctl"); + PERROR("wait quiescent ioctl"); ERR("Kernel quiescent wait failed"); } } @@ -407,7 +436,7 @@ int kernel_calibrate(int fd, struct lttng_kernel_calibrate *calibrate) ret = kernctl_calibrate(fd, calibrate); if (ret < 0) { - perror("calibrate ioctl"); + PERROR("calibrate ioctl"); return -1; } @@ -424,7 +453,7 @@ int kernel_metadata_flush_buffer(int fd) ret = kernctl_buffer_flush(fd); if (ret < 0) { - ERR("Fail to flush metadata buffers %d (ret: %d", fd, ret); + ERR("Fail to flush metadata buffers %d (ret: %d)", fd, ret); } return 0; @@ -444,7 +473,7 @@ int kernel_flush_buffer(struct ltt_kernel_channel *channel) DBG("Flushing channel stream %d", stream->fd); ret = kernctl_buffer_flush(stream->fd); if (ret < 0) { - perror("ioctl"); + PERROR("ioctl"); ERR("Fail to flush buffer for stream %d (ret: %d)", stream->fd, ret); } @@ -481,13 +510,16 @@ error: */ int kernel_open_channel_stream(struct ltt_kernel_channel *channel) { - int ret; + int ret, count = 0; struct ltt_kernel_stream *lks; - while ((ret = kernctl_create_stream(channel->fd)) > 0) { - lks = trace_kernel_create_stream(); + while ((ret = kernctl_create_stream(channel->fd)) >= 0) { + lks = trace_kernel_create_stream(channel->channel->name, count); if (lks == NULL) { - close(ret); + ret = close(ret); + if (ret) { + PERROR("close"); + } goto error; } @@ -495,22 +527,18 @@ int kernel_open_channel_stream(struct ltt_kernel_channel *channel) /* 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/%s_%d", - channel->pathname, channel->channel->name, channel->stream_count); - if (ret < 0) { - perror("asprintf kernel create stream"); - goto error; + PERROR("fcntl session fd"); } /* Add stream to channe stream list */ cds_list_add(&lks->list, &channel->stream_list.head); channel->stream_count++; - DBG("Kernel stream %d created (fd: %d, state: %d, path: %s)", - channel->stream_count, lks->fd, lks->state, lks->pathname); + /* Increment counter which represent CPU number. */ + count++; + + DBG("Kernel stream %s created (fd: %d, state: %d)", lks->name, lks->fd, + lks->state); } return channel->stream_count; @@ -528,7 +556,7 @@ int kernel_open_metadata_stream(struct ltt_kernel_session *session) ret = kernctl_create_stream(session->metadata->fd); if (ret < 0) { - perror("kernel create metadata stream"); + PERROR("kernel create metadata stream"); goto error; } @@ -537,7 +565,7 @@ int kernel_open_metadata_stream(struct ltt_kernel_session *session) /* Prevent fd duplication after execlp() */ ret = fcntl(session->metadata_stream_fd, F_SETFD, FD_CLOEXEC); if (ret < 0) { - perror("fcntl session fd"); + PERROR("fcntl session fd"); } return 0; @@ -551,7 +579,7 @@ error: */ ssize_t kernel_list_events(int tracer_fd, struct lttng_event **events) { - int fd, pos; + int fd, pos, ret; char *event; size_t nbmem, count = 0; ssize_t size; @@ -560,13 +588,13 @@ ssize_t kernel_list_events(int tracer_fd, struct lttng_event **events) fd = kernctl_tracepoint_list(tracer_fd); if (fd < 0) { - perror("kernel tracepoint list"); + PERROR("kernel tracepoint list"); goto error; } fp = fdopen(fd, "r"); if (fp == NULL) { - perror("kernel tracepoint list fdopen"); + PERROR("kernel tracepoint list fdopen"); goto error_fp; } @@ -576,34 +604,116 @@ ssize_t kernel_list_events(int tracer_fd, struct lttng_event **events) */ nbmem = KERNEL_EVENT_INIT_LIST_SIZE; elist = zmalloc(sizeof(struct lttng_event) * nbmem); + if (elist == NULL) { + PERROR("alloc list events"); + count = -ENOMEM; + goto end; + } while ((size = fscanf(fp, "event { name = %m[^;]; };%n\n", &event, &pos)) == 1) { if (count >= nbmem) { + struct lttng_event *new_elist; + DBG("Reallocating event list from %zu to %zu bytes", nbmem, nbmem * 2); /* Double the size */ nbmem <<= 1; - elist = realloc(elist, nbmem * sizeof(struct lttng_event)); - if (elist == NULL) { - perror("realloc list events"); + new_elist = realloc(elist, nbmem * sizeof(struct lttng_event)); + if (new_elist == NULL) { + PERROR("realloc list events"); + free(event); + free(elist); count = -ENOMEM; goto end; } + elist = new_elist; } strncpy(elist[count].name, event, LTTNG_SYMBOL_NAME_LEN); elist[count].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; elist[count].enabled = -1; count++; + free(event); } *events = elist; DBG("Kernel list events done (%zu events)", count); end: - fclose(fp); /* closes both fp and fd */ + ret = fclose(fp); /* closes both fp and fd */ + if (ret) { + PERROR("fclose"); + } return count; error_fp: - close(fd); + ret = close(fd); + if (ret) { + PERROR("close"); + } error: return -1; } + +/* + * Get kernel version and validate it. + */ +int kernel_validate_version(int tracer_fd) +{ + int ret; + struct lttng_kernel_tracer_version version; + + ret = kernctl_tracer_version(tracer_fd, &version); + if (ret < 0) { + ERR("Failed at getting the lttng-modules version"); + goto error; + } + + /* Validate version */ + if (version.major != KERN_MODULES_PRE_MAJOR + && version.major != KERN_MODULES_MAJOR) { + goto error_version; + } + + DBG2("Kernel tracer version validated (major version %d)", version.major); + return 0; + +error_version: + ERR("Kernel major version %d is not compatible (supporting <= %d)", + version.major, KERN_MODULES_MAJOR) + ret = -1; + +error: + return ret; +} + +/* + * Kernel work-arounds called at the start of sessiond main(). + */ +int init_kernel_workarounds(void) +{ + int ret; + FILE *fp; + + /* + * boot_id needs to be read once before being used concurrently + * to deal with a Linux kernel race. A fix is proposed for + * upstream, but the work-around is needed for older kernels. + */ + fp = fopen("/proc/sys/kernel/random/boot_id", "r"); + if (!fp) { + goto end_boot_id; + } + while (!feof(fp)) { + char buf[37] = ""; + + ret = fread(buf, 1, sizeof(buf), fp); + if (ret < 0) { + /* Ignore error, we don't really care */ + } + } + ret = fclose(fp); + if (ret) { + PERROR("fclose"); + } +end_boot_id: + return 0; +}