Rename kernel-ctl.c/.h to kernel.c/.h
authorDavid Goulet <david.goulet@polymtl.ca>
Tue, 29 Nov 2011 19:31:28 +0000 (14:31 -0500)
committerDavid Goulet <david.goulet@polymtl.ca>
Tue, 29 Nov 2011 19:31:28 +0000 (14:31 -0500)
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 <david.goulet@polymtl.ca>
lttng-sessiond/Makefile.am
lttng-sessiond/channel.c
lttng-sessiond/context.c
lttng-sessiond/event.c
lttng-sessiond/kernel-ctl.c [deleted file]
lttng-sessiond/kernel-ctl.h [deleted file]
lttng-sessiond/kernel.c [new file with mode: 0644]
lttng-sessiond/kernel.h [new file with mode: 0644]
lttng-sessiond/main.c
lttng-sessiond/ust-ctl.c [deleted file]

index 755bee4fbc524c5dda35b059d1e56c29412e4bfd..7f97d9d2f7e5486c506346320745cefde6453e47 100644 (file)
@@ -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 \
index 6b3329edd301f247a0ed1f641ee829f2f0a065c5..fb46b4ad6db91fdce417d9f4a9fc185b9e909c2c 100644 (file)
@@ -24,7 +24,7 @@
 
 #include "channel.h"
 #include "hashtable.h"
-#include "kernel-ctl.h"
+#include "kernel.h"
 #include "ust-ctl.h"
 #include "utils.h"
 
index d36b3de80fe318b2b72eceb4ba3064cd6489639b..c7c902197df34fa54143bec06dd437f8db5bf017 100644 (file)
@@ -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.
index 31f7872b66bc39675b939b734eb2e13810880138..2d1fb6e6834a440cfefd2f306b01d22df336831b 100644 (file)
@@ -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 (file)
index 52d60f0..0000000
+++ /dev/null
@@ -1,607 +0,0 @@
-/*
- * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
- *
- * 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 <errno.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-#include <lttng-kernel-ctl.h>
-#include <lttngerr.h>
-
-#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 (file)
index 2fbaca9..0000000
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
- *
- * 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 (file)
index 0000000..c734e88
--- /dev/null
@@ -0,0 +1,607 @@
+/*
+ * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
+ *
+ * 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 <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <lttng-kernel-ctl.h>
+#include <lttngerr.h>
+
+#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 (file)
index 0000000..2fbaca9
--- /dev/null
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
+ *
+ * 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 */
index 996349f3fa12b2329f85f47b0fbc9d406764b543..6bb471a9dca0a3cc03b9448ec0b6be649a12e5e8 100644 (file)
@@ -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 (file)
index 6f73bfc..0000000
+++ /dev/null
@@ -1,226 +0,0 @@
-/*
- * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
- *
- * 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 <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-#include <lttng-sessiond-comm.h>
-#include <lttngerr.h>
-
-#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;
-}
This page took 0.065165 seconds and 4 git commands to generate.