From: David Goulet Date: Tue, 29 Nov 2011 19:31:28 +0000 (-0500) Subject: Rename kernel-ctl.c/.h to kernel.c/.h X-Git-Tag: v2.0-pre15~67 X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=commitdiff_plain;h=4771f025b27e92983c1c0816c4cf5760d229c287 Rename kernel-ctl.c/.h to kernel.c/.h Just to follow the function call standard and since kernelctl exist out of the code tree. Also remove ust-ctl.c which is not used and not compiled at all. Signed-off-by: David Goulet --- diff --git a/lttng-sessiond/Makefile.am b/lttng-sessiond/Makefile.am index 755bee4fb..7f97d9d2f 100644 --- a/lttng-sessiond/Makefile.am +++ b/lttng-sessiond/Makefile.am @@ -16,7 +16,7 @@ lttng_sessiond_SOURCES = utils.c utils.h \ hashtable.c hashtable.h \ compat/poll.h $(COMPAT) \ trace-kernel.c trace-kernel.h \ - kernel-ctl.c kernel-ctl.h \ + kernel.c kernel.h \ ust-ctl.h ust-app.h trace-ust.h \ context.c context.h \ channel.c channel.h \ diff --git a/lttng-sessiond/channel.c b/lttng-sessiond/channel.c index 6b3329edd..fb46b4ad6 100644 --- a/lttng-sessiond/channel.c +++ b/lttng-sessiond/channel.c @@ -24,7 +24,7 @@ #include "channel.h" #include "hashtable.h" -#include "kernel-ctl.h" +#include "kernel.h" #include "ust-ctl.h" #include "utils.h" diff --git a/lttng-sessiond/context.c b/lttng-sessiond/context.c index d36b3de80..c7c902197 100644 --- a/lttng-sessiond/context.c +++ b/lttng-sessiond/context.c @@ -27,7 +27,7 @@ #include "context.h" #include "hashtable.h" -#include "kernel-ctl.h" +#include "kernel.h" /* * Add kernel context to an event of a specific channel. diff --git a/lttng-sessiond/event.c b/lttng-sessiond/event.c index 31f7872b6..2d1fb6e68 100644 --- a/lttng-sessiond/event.c +++ b/lttng-sessiond/event.c @@ -26,7 +26,7 @@ #include "channel.h" #include "event.h" #include "hashtable.h" -#include "kernel-ctl.h" +#include "kernel.h" #include "ust-ctl.h" /* diff --git a/lttng-sessiond/kernel-ctl.c b/lttng-sessiond/kernel-ctl.c deleted file mode 100644 index 52d60f004..000000000 --- a/lttng-sessiond/kernel-ctl.c +++ /dev/null @@ -1,607 +0,0 @@ -/* - * 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 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. - */ - -#define _GNU_SOURCE -#include -#include -#include -#include -#include -#include - -#include -#include - -#include "kernel-ctl.h" - -/* - * 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 = zmalloc(sizeof(struct lttng_kernel_context)); - if (chan->ctx == NULL) { - perror("zmalloc event context"); - goto error; - } - - memcpy(chan->ctx, ctx, sizeof(struct lttng_kernel_context)); - - return 0; - -error: - return ret; -} - -/* - * 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 = zmalloc(sizeof(struct lttng_kernel_context)); - if (event->ctx == NULL) { - perror("zmalloc event context"); - goto error; - } - - memcpy(event->ctx, ctx, sizeof(struct lttng_kernel_context)); - - return 0; - -error: - return ret; -} - -/* - * Create a new kernel session, register it to the kernel tracer and add it to - * the session daemon session. - */ -int kernel_create_session(struct ltt_session *session, int tracer_fd) -{ - int ret; - struct ltt_kernel_session *lks; - - /* Allocate data structure */ - lks = trace_kernel_create_session(session->path); - if (lks == NULL) { - ret = -1; - goto error; - } - - /* Kernel tracer session creation */ - ret = kernctl_create_session(tracer_fd); - if (ret < 0) { - perror("ioctl kernel create session"); - goto error; - } - - lks->fd = ret; - /* Prevent fd duplication after execlp() */ - ret = fcntl(lks->fd, F_SETFD, FD_CLOEXEC); - if (ret < 0) { - perror("fcntl session fd"); - } - - lks->consumer_fds_sent = 0; - session->kernel_session = lks; - - DBG("Kernel session created (fd: %d)", lks->fd); - - return 0; - -error: - return ret; -} - -/* - * 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, char *path) -{ - int ret; - struct ltt_kernel_channel *lkc; - - /* Allocate kernel channel */ - lkc = trace_kernel_create_channel(chan, path); - if (lkc == NULL) { - goto error; - } - - /* Kernel tracer channel creation */ - ret = kernctl_create_channel(session->fd, &lkc->channel->attr); - if (ret < 0) { - perror("ioctl kernel create channel"); - goto error; - } - - /* 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 %s created (fd: %d and path: %s)", - lkc->channel->name, lkc->fd, lkc->pathname); - - return 0; - -error: - return -1; -} - -/* - * 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 lttng_event *ev, - struct ltt_kernel_channel *channel) -{ - int ret; - struct ltt_kernel_event *event; - - event = trace_kernel_create_event(ev); - if (event == NULL) { - ret = -1; - goto error; - } - - ret = kernctl_create_event(channel->fd, event->event); - if (ret < 0) { - if (errno != EEXIST) { - PERROR("create event ioctl"); - } - ret = -errno; - goto free_event; - } - - /* - * LTTNG_KERNEL_SYSCALL event creation will return 0 on success. However - * this FD must not be added to the event list. - */ - if (ret == 0 && event->event->instrumentation == LTTNG_KERNEL_SYSCALL) { - DBG2("Kernel event syscall creation success"); - goto end; - } - - event->fd = ret; - /* 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); - channel->event_count++; - - DBG("Event %s created (fd: %d)", ev->name, event->fd); - -end: - return 0; - -free_event: - free(event); -error: - return ret; -} - -/* - * 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; -} - -/* - * Enable a kernel channel. - */ -int kernel_enable_channel(struct ltt_kernel_channel *chan) -{ - int ret; - - ret = kernctl_enable(chan->fd); - if (ret < 0 && errno != EEXIST) { - perror("Enable kernel chan"); - goto error; - } - - chan->enabled = 1; - DBG("Kernel channel %s enabled (fd: %d)", chan->channel->name, chan->fd); - - return 0; - -error: - return ret; -} - -/* - * Enable a kernel event. - */ -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"); - goto error; - } - - event->enabled = 1; - DBG("Kernel event %s enabled (fd: %d)", event->event->name, event->fd); - - return 0; - -error: - return ret; -} - -/* - * Disable a kernel event. - */ -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"); - goto error; - } - - event->enabled = 0; - DBG("Kernel event %s disabled (fd: %d)", event->event->name, event->fd); - - return 0; - -error: - return ret; -} - -/* - * 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 ret; - struct ltt_kernel_metadata *lkm; - - /* Allocate kernel metadata */ - lkm = trace_kernel_create_metadata(path); - if (lkm == NULL) { - goto error; - } - - /* Kernel tracer metadata creation */ - 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); - - return 0; - -error: - return -1; -} - -/* - * Start tracing session. - */ -int kernel_start_session(struct ltt_kernel_session *session) -{ - int ret; - - ret = kernctl_start_session(session->fd); - if (ret < 0) { - perror("ioctl start session"); - goto error; - } - - DBG("Kernel session started"); - - return 0; - -error: - return ret; -} - -/* - * 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 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; -} - - -/* - * 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; -} - -/* - * 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; -} - -/* - * Stop tracing session. - */ -int kernel_stop_session(struct ltt_kernel_session *session) -{ - int ret; - - ret = kernctl_stop_session(session->fd); - if (ret < 0) { - goto error; - } - - DBG("Kernel session stopped"); - - return 0; - -error: - return ret; -} - -/* - * 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_open_channel_stream(struct ltt_kernel_channel *channel) -{ - int ret; - struct ltt_kernel_stream *lks; - - while ((ret = kernctl_create_stream(channel->fd)) > 0) { - lks = trace_kernel_create_stream(); - if (lks == NULL) { - close(ret); - goto error; - } - - 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/%s_%d", - channel->pathname, channel->channel->name, channel->stream_count); - if (ret < 0) { - perror("asprintf kernel create stream"); - goto error; - } - - /* 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); - } - - return channel->stream_count; - -error: - return -1; -} - -/* - * Open the metadata stream and set it to the kernel session. - */ -int kernel_open_metadata_stream(struct ltt_kernel_session *session) -{ - int ret; - - ret = kernctl_create_stream(session->metadata->fd); - if (ret < 0) { - perror("kernel create metadata stream"); - goto error; - } - - 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; -} - -/* - * Get the event list from the kernel tracer and return the number of elements. - */ -ssize_t kernel_list_events(int tracer_fd, struct lttng_event **events) -{ - 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) { - perror("kernel tracepoint list"); - goto error; - } - - fp = fdopen(fd, "r"); - if (fp == NULL) { - perror("kernel tracepoint list fdopen"); - goto error_fp; - } - - /* - * Init memory size counter - * See kernel-ctl.h for explanation of this value - */ - nbmem = KERNEL_EVENT_LIST_SIZE; - elist = zmalloc(sizeof(struct lttng_event) * nbmem); - - 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 += KERNEL_EVENT_LIST_SIZE; - elist = realloc(elist, nbmem); - if (elist == NULL) { - perror("realloc list events"); - count = -ENOMEM; - goto end; - } - } - strncpy(elist[count].name, event, LTTNG_SYMBOL_NAME_LEN); - elist[count].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; - count++; - } - - *events = elist; - DBG("Kernel list events done (%zu events)", count); -end: - fclose(fp); /* closes both fp and fd */ - return count; - -error_fp: - close(fd); -error: - return -1; -} diff --git a/lttng-sessiond/kernel-ctl.h b/lttng-sessiond/kernel-ctl.h deleted file mode 100644 index 2fbaca91e..000000000 --- a/lttng-sessiond/kernel-ctl.h +++ /dev/null @@ -1,57 +0,0 @@ -/* - * 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 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. - */ - -#ifndef _LTT_KERNEL_CTL_H -#define _LTT_KERNEL_CTL_H - -#include "session.h" -#include "trace-kernel.h" - -/* - * Default size for the event list when kernel_list_events is called. This size - * value is based on the initial LTTng 2.0 version set of tracepoints. - * - * This is NOT an upper bound because if the real event list size is bigger, - * dynamic reallocation is performed. - */ -#define KERNEL_EVENT_LIST_SIZE 80 - -int kernel_add_channel_context(struct ltt_kernel_channel *chan, - struct lttng_kernel_context *ctx); -int kernel_add_event_context(struct ltt_kernel_event *event, - struct lttng_kernel_context *ctx); -int kernel_create_session(struct ltt_session *session, int tracer_fd); -int kernel_create_channel(struct ltt_kernel_session *session, - struct lttng_channel *chan, char *path); -int kernel_create_event(struct lttng_event *ev, struct ltt_kernel_channel *channel); -int kernel_disable_channel(struct ltt_kernel_channel *chan); -int kernel_disable_event(struct ltt_kernel_event *event); -int kernel_enable_event(struct ltt_kernel_event *event); -int kernel_enable_channel(struct ltt_kernel_channel *chan); -int kernel_open_metadata(struct ltt_kernel_session *session, char *path); -int kernel_open_metadata_stream(struct ltt_kernel_session *session); -int kernel_open_channel_stream(struct ltt_kernel_channel *channel); -int kernel_flush_buffer(struct ltt_kernel_channel *channel); -int kernel_metadata_flush_buffer(int fd); -int kernel_start_session(struct ltt_kernel_session *session); -int kernel_stop_session(struct ltt_kernel_session *session); -ssize_t kernel_list_events(int tracer_fd, struct lttng_event **event_list); -void kernel_wait_quiescent(int fd); -int kernel_calibrate(int fd, struct lttng_kernel_calibrate *calibrate); - -#endif /* _LTT_KERNEL_CTL_H */ diff --git a/lttng-sessiond/kernel.c b/lttng-sessiond/kernel.c new file mode 100644 index 000000000..c734e889b --- /dev/null +++ b/lttng-sessiond/kernel.c @@ -0,0 +1,607 @@ +/* + * 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 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. + */ + +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "kernel.h" + +/* + * 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 = zmalloc(sizeof(struct lttng_kernel_context)); + if (chan->ctx == NULL) { + perror("zmalloc event context"); + goto error; + } + + memcpy(chan->ctx, ctx, sizeof(struct lttng_kernel_context)); + + return 0; + +error: + return ret; +} + +/* + * 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 = zmalloc(sizeof(struct lttng_kernel_context)); + if (event->ctx == NULL) { + perror("zmalloc event context"); + goto error; + } + + memcpy(event->ctx, ctx, sizeof(struct lttng_kernel_context)); + + return 0; + +error: + return ret; +} + +/* + * Create a new kernel session, register it to the kernel tracer and add it to + * the session daemon session. + */ +int kernel_create_session(struct ltt_session *session, int tracer_fd) +{ + int ret; + struct ltt_kernel_session *lks; + + /* Allocate data structure */ + lks = trace_kernel_create_session(session->path); + if (lks == NULL) { + ret = -1; + goto error; + } + + /* Kernel tracer session creation */ + ret = kernctl_create_session(tracer_fd); + if (ret < 0) { + perror("ioctl kernel create session"); + goto error; + } + + lks->fd = ret; + /* Prevent fd duplication after execlp() */ + ret = fcntl(lks->fd, F_SETFD, FD_CLOEXEC); + if (ret < 0) { + perror("fcntl session fd"); + } + + lks->consumer_fds_sent = 0; + session->kernel_session = lks; + + DBG("Kernel session created (fd: %d)", lks->fd); + + return 0; + +error: + return ret; +} + +/* + * 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, char *path) +{ + int ret; + struct ltt_kernel_channel *lkc; + + /* Allocate kernel channel */ + lkc = trace_kernel_create_channel(chan, path); + if (lkc == NULL) { + goto error; + } + + /* Kernel tracer channel creation */ + ret = kernctl_create_channel(session->fd, &lkc->channel->attr); + if (ret < 0) { + perror("ioctl kernel create channel"); + goto error; + } + + /* 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 %s created (fd: %d and path: %s)", + lkc->channel->name, lkc->fd, lkc->pathname); + + return 0; + +error: + return -1; +} + +/* + * 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 lttng_event *ev, + struct ltt_kernel_channel *channel) +{ + int ret; + struct ltt_kernel_event *event; + + event = trace_kernel_create_event(ev); + if (event == NULL) { + ret = -1; + goto error; + } + + ret = kernctl_create_event(channel->fd, event->event); + if (ret < 0) { + if (errno != EEXIST) { + PERROR("create event ioctl"); + } + ret = -errno; + goto free_event; + } + + /* + * LTTNG_KERNEL_SYSCALL event creation will return 0 on success. However + * this FD must not be added to the event list. + */ + if (ret == 0 && event->event->instrumentation == LTTNG_KERNEL_SYSCALL) { + DBG2("Kernel event syscall creation success"); + goto end; + } + + event->fd = ret; + /* 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); + channel->event_count++; + + DBG("Event %s created (fd: %d)", ev->name, event->fd); + +end: + return 0; + +free_event: + free(event); +error: + return ret; +} + +/* + * 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; +} + +/* + * Enable a kernel channel. + */ +int kernel_enable_channel(struct ltt_kernel_channel *chan) +{ + int ret; + + ret = kernctl_enable(chan->fd); + if (ret < 0 && errno != EEXIST) { + perror("Enable kernel chan"); + goto error; + } + + chan->enabled = 1; + DBG("Kernel channel %s enabled (fd: %d)", chan->channel->name, chan->fd); + + return 0; + +error: + return ret; +} + +/* + * Enable a kernel event. + */ +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"); + goto error; + } + + event->enabled = 1; + DBG("Kernel event %s enabled (fd: %d)", event->event->name, event->fd); + + return 0; + +error: + return ret; +} + +/* + * Disable a kernel event. + */ +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"); + goto error; + } + + event->enabled = 0; + DBG("Kernel event %s disabled (fd: %d)", event->event->name, event->fd); + + return 0; + +error: + return ret; +} + +/* + * 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 ret; + struct ltt_kernel_metadata *lkm; + + /* Allocate kernel metadata */ + lkm = trace_kernel_create_metadata(path); + if (lkm == NULL) { + goto error; + } + + /* Kernel tracer metadata creation */ + 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); + + return 0; + +error: + return -1; +} + +/* + * Start tracing session. + */ +int kernel_start_session(struct ltt_kernel_session *session) +{ + int ret; + + ret = kernctl_start_session(session->fd); + if (ret < 0) { + perror("ioctl start session"); + goto error; + } + + DBG("Kernel session started"); + + return 0; + +error: + return ret; +} + +/* + * 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 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; +} + + +/* + * 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; +} + +/* + * 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; +} + +/* + * Stop tracing session. + */ +int kernel_stop_session(struct ltt_kernel_session *session) +{ + int ret; + + ret = kernctl_stop_session(session->fd); + if (ret < 0) { + goto error; + } + + DBG("Kernel session stopped"); + + return 0; + +error: + return ret; +} + +/* + * 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_open_channel_stream(struct ltt_kernel_channel *channel) +{ + int ret; + struct ltt_kernel_stream *lks; + + while ((ret = kernctl_create_stream(channel->fd)) > 0) { + lks = trace_kernel_create_stream(); + if (lks == NULL) { + close(ret); + goto error; + } + + 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/%s_%d", + channel->pathname, channel->channel->name, channel->stream_count); + if (ret < 0) { + perror("asprintf kernel create stream"); + goto error; + } + + /* 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); + } + + return channel->stream_count; + +error: + return -1; +} + +/* + * Open the metadata stream and set it to the kernel session. + */ +int kernel_open_metadata_stream(struct ltt_kernel_session *session) +{ + int ret; + + ret = kernctl_create_stream(session->metadata->fd); + if (ret < 0) { + perror("kernel create metadata stream"); + goto error; + } + + 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; +} + +/* + * Get the event list from the kernel tracer and return the number of elements. + */ +ssize_t kernel_list_events(int tracer_fd, struct lttng_event **events) +{ + 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) { + perror("kernel tracepoint list"); + goto error; + } + + fp = fdopen(fd, "r"); + if (fp == NULL) { + perror("kernel tracepoint list fdopen"); + goto error_fp; + } + + /* + * Init memory size counter + * See kernel-ctl.h for explanation of this value + */ + nbmem = KERNEL_EVENT_LIST_SIZE; + elist = zmalloc(sizeof(struct lttng_event) * nbmem); + + 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 += KERNEL_EVENT_LIST_SIZE; + elist = realloc(elist, nbmem); + if (elist == NULL) { + perror("realloc list events"); + count = -ENOMEM; + goto end; + } + } + strncpy(elist[count].name, event, LTTNG_SYMBOL_NAME_LEN); + elist[count].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; + count++; + } + + *events = elist; + DBG("Kernel list events done (%zu events)", count); +end: + fclose(fp); /* closes both fp and fd */ + return count; + +error_fp: + close(fd); +error: + return -1; +} diff --git a/lttng-sessiond/kernel.h b/lttng-sessiond/kernel.h new file mode 100644 index 000000000..2fbaca91e --- /dev/null +++ b/lttng-sessiond/kernel.h @@ -0,0 +1,57 @@ +/* + * 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 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. + */ + +#ifndef _LTT_KERNEL_CTL_H +#define _LTT_KERNEL_CTL_H + +#include "session.h" +#include "trace-kernel.h" + +/* + * Default size for the event list when kernel_list_events is called. This size + * value is based on the initial LTTng 2.0 version set of tracepoints. + * + * This is NOT an upper bound because if the real event list size is bigger, + * dynamic reallocation is performed. + */ +#define KERNEL_EVENT_LIST_SIZE 80 + +int kernel_add_channel_context(struct ltt_kernel_channel *chan, + struct lttng_kernel_context *ctx); +int kernel_add_event_context(struct ltt_kernel_event *event, + struct lttng_kernel_context *ctx); +int kernel_create_session(struct ltt_session *session, int tracer_fd); +int kernel_create_channel(struct ltt_kernel_session *session, + struct lttng_channel *chan, char *path); +int kernel_create_event(struct lttng_event *ev, struct ltt_kernel_channel *channel); +int kernel_disable_channel(struct ltt_kernel_channel *chan); +int kernel_disable_event(struct ltt_kernel_event *event); +int kernel_enable_event(struct ltt_kernel_event *event); +int kernel_enable_channel(struct ltt_kernel_channel *chan); +int kernel_open_metadata(struct ltt_kernel_session *session, char *path); +int kernel_open_metadata_stream(struct ltt_kernel_session *session); +int kernel_open_channel_stream(struct ltt_kernel_channel *channel); +int kernel_flush_buffer(struct ltt_kernel_channel *channel); +int kernel_metadata_flush_buffer(int fd); +int kernel_start_session(struct ltt_kernel_session *session); +int kernel_stop_session(struct ltt_kernel_session *session); +ssize_t kernel_list_events(int tracer_fd, struct lttng_event **event_list); +void kernel_wait_quiescent(int fd); +int kernel_calibrate(int fd, struct lttng_kernel_calibrate *calibrate); + +#endif /* _LTT_KERNEL_CTL_H */ diff --git a/lttng-sessiond/main.c b/lttng-sessiond/main.c index 996349f3f..6bb471a9d 100644 --- a/lttng-sessiond/main.c +++ b/lttng-sessiond/main.c @@ -50,7 +50,7 @@ #include "event.h" #include "futex.h" #include "hashtable.h" -#include "kernel-ctl.h" +#include "kernel.h" #include "lttng-sessiond.h" #include "shm.h" #include "ust-app.h" diff --git a/lttng-sessiond/ust-ctl.c b/lttng-sessiond/ust-ctl.c deleted file mode 100644 index 6f73bfc66..000000000 --- a/lttng-sessiond/ust-ctl.c +++ /dev/null @@ -1,226 +0,0 @@ -/* - * 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 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. - */ - -#define _GNU_SOURCE -#include -#include -#include -#include - -#include -#include - -#include "ust-comm.h" -#include "ust-ctl.h" -#include "../hashtable/hash.h" - -/* - * Init command for tracer with cmd type and correct handle. - */ -static void init_command(int cmd, int handle, struct lttcomm_ust_msg *command) -{ - memset(command, 0, sizeof(struct lttcomm_ust_msg)); - - command->cmd = cmd; - command->handle = handle; -} - -/* - * Generic send command to ust tracer. Caller must free reply. - */ -static struct lttcomm_ust_reply *send_command(int sock, - struct lttcomm_ust_msg *command) -{ - struct lttcomm_ust_reply *reply; - - reply = ustcomm_send_command(sock, command); - if (reply == NULL) { - goto error; - } - - if (reply->ret_code != LTTCOMM_OK) { - ERR("Return code (%d): %s", reply->ret_code, - lttcomm_get_readable_code(reply->ret_code)); - goto error; - } - - return reply; - -error: - return NULL; -} - -/* - * Send registration done packet to the application. - */ -int ustctl_register_done(int sock) -{ - struct lttcomm_ust_msg command; - struct lttcomm_ust_reply *reply; - - DBG("Sending register done command to %d", sock); - - command.cmd = LTTNG_UST_REGISTER_DONE; - command.handle = LTTNG_UST_ROOT_HANDLE; - - reply = ustcomm_send_command(sock, &command); - if (reply == NULL) { - goto error; - } - - if (reply->ret_code != LTTCOMM_OK) { - DBG("Return code: %s", lttcomm_get_readable_code(reply->ret_code)); - goto error; - } - - return 0; - -error: - return -1; -} - -/* - * Create an UST session on the tracer. - * - * Return handle if success else negative value. - */ -int ustctl_create_session(int sock, struct ltt_ust_session *session) -{ - int ret; - struct lttcomm_ust_msg command; - struct lttcomm_ust_reply *reply = NULL; - - command.cmd = LTTNG_UST_SESSION; - command.handle = LTTNG_UST_ROOT_HANDLE; - - reply = ustcomm_send_command(sock, &command); - if (reply == NULL) { - goto error; - } - - /* Save session handle */ - ret = reply->ret_val; - free(reply); - - DBG2("ustctl create session command successful with handle %d", ret); - - return ret; - -error: - free(reply); - return -1; -} - -/* - * Create UST channel to the tracer. - * - * Return handle if success else negative value. - */ -int ustctl_create_channel(int sock, struct ltt_ust_session *session, - struct lttng_ust_channel *channel) -{ - int ret; - struct lttcomm_ust_msg command; - struct lttcomm_ust_reply *reply = NULL; - - init_command(LTTNG_UST_CHANNEL, session->handle, &command); - /* Copy channel attributes to command */ - memcpy(&command.u.channel, channel, sizeof(command.u.channel)); - - /* Send command to tracer */ - reply = send_command(sock, &command); - if (reply == NULL) { - goto error; - } - - ret = reply->ret_val; - free(reply); - - return ret; - -error: - free(reply); - return -1; -} - -/* - * Enable UST channel. - */ -int ustctl_enable_channel(int sock, struct ltt_ust_session *session, - struct ltt_ust_channel *chan) -{ - struct lttcomm_ust_msg command; - struct lttcomm_ust_reply *reply = NULL; - - init_command(LTTNG_UST_ENABLE, chan->handle, &command); - - reply = ustcomm_send_command(sock, &command); - if (reply == NULL) { - goto error; - } - - if (reply->handle != chan->handle) { - ERR("Receive wrong handle from UST reply on enable channel"); - goto error; - } - - chan->enabled = 1; - free(reply); - - DBG2("ustctl enable channel successful for sock %d", sock); - return 0; - -error: - free(reply); - return -1; -} - -/* - * Disable UST channel. - */ -int ustctl_disable_channel(int sock, struct ltt_ust_session *session, - struct ltt_ust_channel *chan) -{ - struct lttcomm_ust_msg command; - struct lttcomm_ust_reply *reply = NULL; - - memset(&command, 0, sizeof(command)); - - command.cmd = LTTNG_UST_DISABLE; - command.handle = chan->handle; - - reply = ustcomm_send_command(sock, &command); - if (reply == NULL) { - goto error; - } - - if (reply->handle != chan->handle) { - ERR("Receive wrong handle from UST reply on enable channel"); - goto error; - } - - chan->enabled = 1; - free(reply); - - DBG2("ustctl disable channel successful for sock %d", sock); - return 0; - -error: - free(reply); - return -1; -}