Add kernel trace data structure init functions
authorDavid Goulet <david.goulet@polymtl.ca>
Fri, 27 May 2011 17:54:12 +0000 (13:54 -0400)
committerDavid Goulet <david.goulet@polymtl.ca>
Fri, 27 May 2011 17:54:12 +0000 (13:54 -0400)
Adds back trace.c file which contains kernel trace data structure
initialization functions.

This simplifies a lot the kernel data structure creation and makes it
more modular to operate on those data type.

Signed-off-by: David Goulet <david.goulet@polymtl.ca>
ltt-sessiond/Makefile.am
ltt-sessiond/kernel-ctl.c
ltt-sessiond/ltt-sessiond.h
ltt-sessiond/trace.c [new file with mode: 0644]
ltt-sessiond/trace.h

index 4d634a90a8d3b0cc03725a91b6695f74564746d1..b7200064f759c5222342a1e596bf96cf51ff4bdb 100644 (file)
@@ -3,7 +3,7 @@ AM_CFLAGS = -fno-strict-aliasing
 
 bin_PROGRAMS = ltt-sessiond
 
-ltt_sessiond_SOURCES = session.c traceable-app.c ust-ctl.c kernel-ctl.c main.c
+ltt_sessiond_SOURCES = trace.c session.c traceable-app.c ust-ctl.c kernel-ctl.c main.c
 
 ltt_sessiond_LDADD = \
                 $(top_builddir)/liblttsessiondcomm/liblttsessiondcomm.la \
index 352dabbb0edd02bab7c36d4cc4ac416a07938a66..a4d8099f9f773b1ca485dd8cea6c6d08c635e518 100644 (file)
 /*
  *  kernel_create_session
  *
- *  Create a new kernel session using the command context session.
+ *  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 a new kernel session */
-       lks = malloc(sizeof(struct ltt_kernel_session));
+       /* Allocate data structure */
+       lks = trace_create_kernel_session();
        if (lks == NULL) {
-               perror("kernel session malloc");
-               ret = -errno;
+               ret = -1;
                goto error;
        }
 
+       /* Kernel tracer session creation */
        ret = kernctl_create_session(tracer_fd);
        if (ret < 0) {
+               perror("ioctl kernel create session");
                goto error;
        }
 
-       /* Assigning session fd and to the command context */
        lks->fd = ret;
-       lks->channel_count = 0;
-       lks->stream_count_global = 0;
        session->kernel_session = lks;
        session->kern_session_count++;
-       CDS_INIT_LIST_HEAD(&lks->channel_list.head);
 
        DBG("Kernel session created (fd: %d)", lks->fd);
 
@@ -70,88 +68,60 @@ error:
 /*
  *  kernel_create_channel
  *
- *  Create a kernel channel within the kernel session.
+ *  Create a kernel channel, register it to the kernel tracer and add it to the
+ *  kernel session.
  */
 int kernel_create_channel(struct ltt_kernel_session *session)
 {
        int ret;
        struct ltt_kernel_channel *lkc;
-       struct lttng_kernel_channel *chan;
 
-       lkc = malloc(sizeof(struct ltt_kernel_channel));
-       chan = malloc(sizeof(struct lttng_kernel_channel));
-
-       if (lkc == NULL || chan == NULL) {
-               perror("kernel channel malloc");
-               ret = -errno;
+       /* Allocate kernel channel */
+       lkc = trace_create_kernel_channel();
+       if (lkc == NULL) {
                goto error;
        }
 
-       chan->overwrite = DEFAULT_KERNEL_OVERWRITE;
-       chan->subbuf_size = DEFAULT_KERNEL_SUBBUF_SIZE;
-       chan->num_subbuf = DEFAULT_KERNEL_SUBBUF_NUM;
-       chan->switch_timer_interval = DEFAULT_KERNEL_SWITCH_TIMER;
-       chan->read_timer_interval = DEFAULT_KERNEL_READ_TIMER;
-
-       ret = kernctl_create_channel(session->fd, chan);
+       /* Kernel tracer channel creation */
+       ret = kernctl_create_channel(session->fd, lkc->channel);
        if (ret < 0) {
-               perror("ioctl create channel");
+               perror("ioctl kernel create channel");
                goto error;
        }
 
-       /* Setup the channel */
+       /* Setup the channel fd */
        lkc->fd = ret;
-       lkc->channel = chan;
-       lkc->stream_count = 0;
-       ret = asprintf(&lkc->pathname, "%s", DEFAULT_TRACE_OUTPUT);
-       if (ret < 0) {
-               perror("asprintf kernel create channel");
-               goto error;
-       }
-
-       DBG("Channel path set to %s", lkc->pathname);
-
-       CDS_INIT_LIST_HEAD(&lkc->events_list.head);
-       CDS_INIT_LIST_HEAD(&lkc->stream_list.head);
+       /* Add channel to session */
        cds_list_add(&lkc->list, &session->channel_list.head);
        session->channel_count++;
 
-       DBG("Kernel channel created (fd: %d)", lkc->fd);
+       DBG("Kernel channel created (fd: %d and path: %s)", lkc->fd, lkc->pathname);
 
        return 0;
 
 error:
-       return ret;
+       return -1;
 }
 
 /*
  *  kernel_enable_event
  *
- *  Enable kernel event.
+ *  Create a kernel event, enable it to the kernel tracer and add it to the
+ *  channel event list of the kernel session.
  */
 int kernel_enable_event(struct ltt_kernel_session *session, char *name)
 {
        int ret;
        struct ltt_kernel_channel *chan;
        struct ltt_kernel_event *event;
-       struct lttng_kernel_event *lke;
-
-       event = malloc(sizeof(struct ltt_kernel_event));
-       lke = malloc(sizeof(struct lttng_kernel_event));
 
-       if (event == NULL || lke == NULL) {
-               perror("kernel enable event malloc");
-               ret = -errno;
+       event = trace_create_kernel_event(name, LTTNG_KERNEL_TRACEPOINTS);
+       if (event == NULL) {
                goto error;
        }
 
-       /* Setting up a kernel event */
-       strncpy(lke->name, name, LTTNG_SYM_NAME_LEN);
-       lke->instrumentation = LTTNG_KERNEL_TRACEPOINTS;
-       event->event = lke;
-
        cds_list_for_each_entry(chan, &session->channel_list.head, list) {
-               ret = kernctl_create_event(chan->fd, lke);
+               ret = kernctl_create_event(chan->fd, event->event);
                if (ret < 0) {
                        goto error;
                }
@@ -165,55 +135,41 @@ int kernel_enable_event(struct ltt_kernel_session *session, char *name)
        return 0;
 
 error:
-       return ret;
+       return -1;
 }
 
 /*
  *  kernel_open_metadata
  *
- *  Open metadata stream.
+ *  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 ret;
        struct ltt_kernel_metadata *lkm;
-       struct lttng_kernel_channel *conf;
 
-       lkm = malloc(sizeof(struct ltt_kernel_metadata));
-       conf = malloc(sizeof(struct lttng_kernel_channel));
-
-       if (lkm == NULL || conf == NULL) {
-               perror("kernel open metadata malloc");
-               ret = -errno;
+       /* Allocate kernel metadata */
+       lkm = trace_create_kernel_metadata();
+       if (lkm == NULL) {
                goto error;
        }
 
-       conf->overwrite = DEFAULT_KERNEL_OVERWRITE;
-       conf->subbuf_size = DEFAULT_KERNEL_SUBBUF_SIZE;
-       conf->num_subbuf = DEFAULT_KERNEL_SUBBUF_NUM;
-       conf->switch_timer_interval = DEFAULT_KERNEL_SWITCH_TIMER;
-       conf->read_timer_interval = DEFAULT_KERNEL_READ_TIMER;
-
-       ret = kernctl_open_metadata(session->fd, conf);
+       /* Kernel tracer metadata creation */
+       ret = kernctl_open_metadata(session->fd, lkm->conf);
        if (ret < 0) {
                goto error;
        }
 
        lkm->fd = ret;
-       lkm->conf = conf;
-       ret = asprintf(&lkm->pathname, "%s/metadata", DEFAULT_TRACE_OUTPUT);
-       if (ret < 0) {
-               perror("asprintf kernel metadata");
-               goto error;
-       }
        session->metadata = lkm;
 
-       DBG("Kernel metadata opened (fd: %d)", lkm->fd);
+       DBG("Kernel metadata opened (fd: %d and path: %s)", lkm->fd, lkm->pathname);
 
        return 0;
 
 error:
-       return ret;
+       return -1;
 }
 
 /*
@@ -263,7 +219,8 @@ error:
 /*
  *  kernel_create_channel_stream
  *
- *  Create a stream for a channel.
+ *  Create a stream for a 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.
  */
@@ -273,10 +230,9 @@ int kernel_create_channel_stream(struct ltt_kernel_channel *channel)
        struct ltt_kernel_stream *lks;
 
        while ((ret = kernctl_create_stream(channel->fd)) > 0) {
-               lks = malloc(sizeof(struct ltt_kernel_stream));
+               lks = trace_create_kernel_stream();
                if (lks == NULL) {
-                       perror("kernel create stream malloc");
-                       ret = -errno;
+                       close(ret);
                        goto error;
                }
 
@@ -287,24 +243,25 @@ int kernel_create_channel_stream(struct ltt_kernel_channel *channel)
                        perror("asprintf kernel create stream");
                        goto error;
                }
-               lks->state = 0;
 
+               /* Add stream to channe stream list */
                cds_list_add(&lks->list, &channel->stream_list.head);
                channel->stream_count++;
-       }
 
-       DBG("Kernel channel stream created (num: %d)", 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 ret;
+       return -1;
 }
 
 /*
  *  kernel_create_metadata_stream
  *
- *  Create the metadata stream.
+ *  Create the metadata stream and set it to the kernel session.
  */
 int kernel_create_metadata_stream(struct ltt_kernel_session *session)
 {
@@ -313,7 +270,6 @@ int kernel_create_metadata_stream(struct ltt_kernel_session *session)
        ret = kernctl_create_stream(session->metadata->fd);
        if (ret < 0) {
                perror("kernel create metadata stream");
-               ret = -errno;
                goto error;
        }
 
@@ -323,5 +279,5 @@ int kernel_create_metadata_stream(struct ltt_kernel_session *session)
        return 0;
 
 error:
-       return ret;
+       return -1;
 }
index 161da0d8e60547169b1da8e061e119b9c468d82d..af48cd92a39c16b5da4e314056c6868705b2e707 100644 (file)
  * Kernel tracer defines
  */
 #define DEFAULT_KERNEL_TRACER_PATH                     "/mnt/debugfs/lttng"
-#define DEFAULT_KERNEL_OVERWRITE            0
-#define DEFAULT_KERNEL_SUBBUF_SIZE          4096    /* bytes */
-#define DEFAULT_KERNEL_SUBBUF_NUM           8       /* Must always be a power of 2 */
-#define DEFAULT_KERNEL_SWITCH_TIMER         0       /* usec */
-#define DEFAULT_KERNEL_READ_TIMER           200     /* usec */
 
 extern const char default_home_dir[],
        default_tracing_group[],
diff --git a/ltt-sessiond/trace.c b/ltt-sessiond/trace.c
new file mode 100644 (file)
index 0000000..8b1d15e
--- /dev/null
@@ -0,0 +1,209 @@
+/*
+ * 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; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <urcu/list.h>
+
+#include "ltt-sessiond.h"
+#include "trace.h"
+
+/*
+ *  trace_create_kernel_session
+ *
+ *  Allocate and initialize a kernel session data structure.
+ *
+ *  Return pointer to structure or NULL.
+ */
+struct ltt_kernel_session *trace_create_kernel_session(void)
+{
+       struct ltt_kernel_session *lks;
+
+       /* Allocate a new ltt kernel session */
+       lks = malloc(sizeof(struct ltt_kernel_session));
+       if (lks == NULL) {
+               perror("create kernel session malloc");
+               goto error;
+       }
+
+       /* Init data structure */
+       lks->fd = 0;
+       lks->metadata_stream_fd = 0;
+       lks->channel_count = 0;
+       lks->stream_count_global = 0;
+       lks->metadata = NULL;
+       CDS_INIT_LIST_HEAD(&lks->channel_list.head);
+
+       return lks;
+
+error:
+       return NULL;
+}
+
+/*
+ *  trace_create_kernel_channel
+ *
+ *  Allocate and initialize a kernel channel data structure.
+ *
+ *  Return pointer to structure or NULL.
+ */
+struct ltt_kernel_channel *trace_create_kernel_channel(void)
+{
+       int ret;
+       struct ltt_kernel_channel *lkc;
+       struct lttng_kernel_channel *chan;
+
+       lkc = malloc(sizeof(struct ltt_kernel_channel));
+       chan = malloc(sizeof(struct lttng_kernel_channel));
+       if (lkc == NULL || chan == NULL) {
+               perror("kernel channel malloc");
+               goto error;
+       }
+
+       /* Default value to channel */
+       chan->overwrite = DEFAULT_KERNEL_OVERWRITE;
+       chan->subbuf_size = DEFAULT_KERNEL_SUBBUF_SIZE;
+       chan->num_subbuf = DEFAULT_KERNEL_SUBBUF_NUM;
+       chan->switch_timer_interval = DEFAULT_KERNEL_SWITCH_TIMER;
+       chan->read_timer_interval = DEFAULT_KERNEL_READ_TIMER;
+
+       lkc->fd = 0;
+       lkc->stream_count = 0;
+       lkc->channel = chan;
+       /* Init linked list */
+       CDS_INIT_LIST_HEAD(&lkc->events_list.head);
+       CDS_INIT_LIST_HEAD(&lkc->stream_list.head);
+       /* Set default trace output path */
+       ret = asprintf(&lkc->pathname, "%s", DEFAULT_TRACE_OUTPUT);
+       if (ret < 0) {
+               perror("asprintf kernel create channel");
+               goto error;
+       }
+
+       return lkc;
+
+error:
+       return NULL;
+}
+
+/*
+ *  trace_create_kernel_event
+ *
+ *  Allocate and initialize a kernel event. Set name and event type.
+ *
+ *  Return pointer to structure or NULL.
+ */
+struct ltt_kernel_event *trace_create_kernel_event(char *name,
+               enum lttng_kernel_instrumentation type)
+{
+       struct ltt_kernel_event *lke;
+       struct lttng_kernel_event *attr;
+
+       lke = malloc(sizeof(struct ltt_kernel_event));
+       attr = malloc(sizeof(struct lttng_kernel_event));
+       if (lke == NULL || attr == NULL) {
+               perror("kernel event malloc");
+               goto error;
+       }
+
+       /* Init event attribute */
+       attr->instrumentation = type;
+       strncpy(attr->name, name, LTTNG_SYM_NAME_LEN);
+       /* Setting up a kernel event */
+       lke->fd = 0;
+       lke->event = attr;
+
+       return lke;
+
+error:
+       return NULL;
+}
+
+/*
+ *  trace_create_kernel_metadata
+ *
+ *  Allocate and initialize a kernel metadata.
+ *
+ *  Return pointer to structure or NULL.
+ */
+struct ltt_kernel_metadata *trace_create_kernel_metadata(void)
+{
+       int ret;
+       struct ltt_kernel_metadata *lkm;
+       struct lttng_kernel_channel *attr;
+
+       lkm = malloc(sizeof(struct ltt_kernel_metadata));
+       attr = malloc(sizeof(struct lttng_kernel_channel));
+       if (lkm == NULL || attr == NULL) {
+               perror("kernel metadata malloc");
+               goto error;
+       }
+
+       /* Set default attributes */
+       attr->overwrite = DEFAULT_KERNEL_OVERWRITE;
+       attr->subbuf_size = DEFAULT_KERNEL_SUBBUF_SIZE;
+       attr->num_subbuf = DEFAULT_KERNEL_SUBBUF_NUM;
+       attr->switch_timer_interval = DEFAULT_KERNEL_SWITCH_TIMER;
+       attr->read_timer_interval = DEFAULT_KERNEL_READ_TIMER;
+
+       /* Init metadata */
+       lkm->fd = 0;
+       lkm->conf = attr;
+       /* Set default metadata path */
+       ret = asprintf(&lkm->pathname, "%s/metadata", DEFAULT_TRACE_OUTPUT);
+       if (ret < 0) {
+               perror("asprintf kernel metadata");
+               goto error;
+       }
+
+       return lkm;
+
+error:
+       return NULL;
+}
+
+/*
+ *  trace_create_kernel_stream
+ *
+ *  Allocate and initialize a kernel stream. The stream is set to ACTIVE_FD by
+ *  default.
+ *
+ *  Return pointer to structure or NULL.
+ */
+struct ltt_kernel_stream *trace_create_kernel_stream(void)
+{
+       struct ltt_kernel_stream *lks;
+
+       lks = malloc(sizeof(struct ltt_kernel_stream));
+       if (lks == NULL) {
+               perror("kernel stream malloc");
+               goto error;
+       }
+
+       /* Init stream */
+       lks->fd = 0;
+       lks->pathname = NULL;
+       lks->state = 0;
+
+       return lks;
+
+error:
+       return NULL;
+}
index f0d25c89400db78de651f36850a78db95ebb1c8b..488fd757d3dfabf4d06a894ad2375876f6857cf6 100644 (file)
 #include <urcu/list.h>
 #include "lttng-kernel.h"
 
+/* Default kernel channel attributes */
+#define DEFAULT_KERNEL_OVERWRITE            0
+#define DEFAULT_KERNEL_SUBBUF_SIZE          4096    /* bytes */
+#define DEFAULT_KERNEL_SUBBUF_NUM           8       /* Must always be a power of 2 */
+#define DEFAULT_KERNEL_SWITCH_TIMER         0       /* usec */
+#define DEFAULT_KERNEL_READ_TIMER           200     /* usec */
+
 /* Kernel event list */
 struct ltt_kernel_event_list {
        struct cds_list_head head;
@@ -96,4 +103,24 @@ struct ltt_ust_marker {
        char *channel;
 };
 
+/*
+ * Function prototype
+ */
+
+/* Kernel session */
+struct ltt_kernel_session *trace_create_kernel_session(void);
+
+/* Kernel channel */
+struct ltt_kernel_channel *trace_create_kernel_channel(void);
+
+/* Kernel event */
+struct ltt_kernel_event *trace_create_kernel_event(char *name,
+               enum lttng_kernel_instrumentation type);
+
+/* Kernel metadata */
+struct ltt_kernel_metadata *trace_create_kernel_metadata(void);
+
+/* Kernel stream */
+struct ltt_kernel_stream *trace_create_kernel_stream(void);
+
 #endif /* _LTT_TRACE_H */
This page took 0.053652 seconds and 4 git commands to generate.