X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=ltt-sessiond%2Fkernel-ctl.c;h=cfea8942da7f421d4eeaf272f59b51261fe08e3e;hp=bc92ffca918cb07b524aa8b9a6865308e455761b;hb=50ecdf72034d220d3b0300d0caa13e6946be555b;hpb=d36b858358a8ef4e00de843379d670925f9c23b6 diff --git a/ltt-sessiond/kernel-ctl.c b/ltt-sessiond/kernel-ctl.c index bc92ffca9..cfea8942d 100644 --- a/ltt-sessiond/kernel-ctl.c +++ b/ltt-sessiond/kernel-ctl.c @@ -3,8 +3,8 @@ * * 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; either version 2 - * of the License, or (at your option) any later version. + * as published by the Free Software Foundation; only version 2 + * of the License. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -25,10 +25,76 @@ #include #include "lttngerr.h" -#include "ltt-sessiond.h" -#include "libkernelctl.h" +#include "kernelctl.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) { + if (errno != EEXIST) { + perror("add context ioctl"); + } else { + /* If EEXIST, we just ignore the error */ + ret = 0; + } + 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 +129,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 +144,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; } @@ -149,6 +214,8 @@ int kernel_create_event(struct lttng_event *ev, struct ltt_kernel_channel *chann /* 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); return 0; @@ -159,6 +226,31 @@ 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 * @@ -196,6 +288,9 @@ int kernel_enable_event(struct ltt_kernel_event *event) ret = kernctl_enable(event->fd); if (ret < 0) { perror("enable event ioctl"); + if (errno == EEXIST) { + ret = -EEXIST; + } goto error; } @@ -238,13 +333,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; } @@ -313,6 +408,23 @@ void kernel_wait_quiescent(int fd) } } +/* + * kernel_calibrate + */ +int kernel_calibrate(int fd, struct lttng_kernel_calibrate *calibrate) +{ + int ret; + + ret = kernctl_calibrate(fd, calibrate); + if (ret < 0) { + perror("calibrate ioctl"); + return -1; + } + + return 0; +} + + /* * kernel_metadata_flush_buffer * @@ -404,8 +516,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; @@ -455,18 +567,16 @@ error: } /* - * kernel_list_events - * - * Get the event list from the kernel tracer and return that list in the CTF - * format. + * Get the event list from the kernel tracer and return the number of elements. */ -ssize_t kernel_list_events(int tracer_fd, char **list) +ssize_t kernel_list_events(int tracer_fd, struct lttng_event **events) { - int fd; - char *buf, *line = NULL; - size_t nb, nbmem, total = 0; + int fd, pos; + char *event; + size_t nbmem, count = 0; ssize_t size; FILE *fp; + struct lttng_event *elist; fd = kernctl_tracepoint_list(tracer_fd); if (fd < 0) { @@ -485,29 +595,30 @@ ssize_t kernel_list_events(int tracer_fd, char **list) * See kernel-ctl.h for explanation of this value */ nbmem = KERNEL_EVENT_LIST_SIZE; - buf = malloc(nbmem); + elist = malloc(sizeof(struct lttng_event) * 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); + while ((size = fscanf(fp, "event { name = %m[^;]; };%n\n", &event, &pos)) == 1) { + if (count > nbmem) { + DBG("Reallocating event list from %zu to %zu bytes", nbmem, + nbmem + KERNEL_EVENT_LIST_SIZE); /* Adding the default size again */ - nbmem = total + size + KERNEL_EVENT_LIST_SIZE; - buf = realloc(buf, nbmem); - if (buf == NULL) { + nbmem += KERNEL_EVENT_LIST_SIZE; + elist = realloc(elist, nbmem); + if (elist == NULL) { perror("realloc list events"); goto error; } } - memcpy(buf + total, line, size); - total += size; + strncpy(elist[count].name, event, LTTNG_SYMBOL_NAME_LEN); + elist[count].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; + count++; } - *list = buf; + *events = elist; - DBG("Kernel list events done"); + DBG("Kernel list events done (%zu events)", count); - return total; + return count; error: return -1;