Rename trace.c/.h to trace-kernel
authorDavid Goulet <david.goulet@polymtl.ca>
Fri, 26 Aug 2011 15:30:32 +0000 (11:30 -0400)
committerDavid Goulet <david.goulet@polymtl.ca>
Fri, 26 Aug 2011 16:28:02 +0000 (12:28 -0400)
Note that the file only contains evidently kernel data structures and
functions signatures.

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

index 2f65a2fb87f96561e310c6af7572b9aee6471bb7..1603b29c62d80047418ddc00b637d8093f10d698 100644 (file)
@@ -5,11 +5,16 @@ AM_CFLAGS = -fno-strict-aliasing
 
 bin_PROGRAMS = ltt-sessiond
 
-ltt_sessiond_SOURCES = utils.c trace.c session.c traceable-app.c ust-ctl.c \
-                       kernel-ctl.c context.c futex.c futex.h \
-                       utils.h trace.h session.h traceable-app.h ust-ctl.h \
+ltt_sessiond_SOURCES = utils.c utils.h \
+                       trace-kernel.c trace-kernel.h \
+                       session.c session.h \
+                       traceable-app.c traceable-app.h \
+                       ust-ctl.c ust-ctl.h \
+                       kernel-ctl.c kernel-ctl.h \
+                       context.c context.h \
+                       futex.c futex.h \
                        ust-comm.c ust-comm.h \
-                       context.h kernel-ctl.h ltt-sessiond.h main.c
+                       ltt-sessiond.h main.c
 
 # link on liblttngctl for check if sessiond is already alive.
 ltt_sessiond_LDADD = \
index 7ec75ffafd8c560a455562d276b5fc5374f04264..aebee06074417e39c39b857047e0b6a033c0b4af 100644 (file)
@@ -39,7 +39,7 @@ static int add_kctx_to_event(struct lttng_kernel_context *kctx,
 
        DBG("Add kernel context to event %s", event_name);
 
-       kevent = get_kernel_event_by_name(event_name, kchan);
+       kevent = trace_kernel_get_event_by_name(event_name, kchan);
        if (kevent != NULL) {
                ret = kernel_add_event_context(kevent, kctx);
                if (ret < 0) {
@@ -165,7 +165,7 @@ int add_kernel_context(struct ltt_kernel_session *ksession,
                }
        } else {
                /* Get kernel channel */
-               kchan = get_kernel_channel_by_name(channel_name, ksession);
+               kchan = trace_kernel_get_channel_by_name(channel_name, ksession);
                if (kchan == NULL) {
                        ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
                        goto error;
index c8cd627761f13cdc3a98a06fe714cd83325decd4..a3d82e0b7d5af55c5cc664d58e73f65bfa352bdd 100644 (file)
@@ -20,7 +20,7 @@
 
 #include <lttng-kernel.h>
 
-#include "trace.h"
+#include "trace-kernel.h"
 
 int add_kernel_context(struct ltt_kernel_session *ksession,
                struct lttng_kernel_context *kctx, char *event_name,
index 6247ce6bdd69ccd78162e1f422a490de1fb12030..d088115f78380cddc15e1f038b1980ffa16ed4b1 100644 (file)
@@ -102,7 +102,7 @@ int kernel_create_session(struct ltt_session *session, int tracer_fd)
        struct ltt_kernel_session *lks;
 
        /* Allocate data structure */
-       lks = trace_create_kernel_session();
+       lks = trace_kernel_create_session();
        if (lks == NULL) {
                ret = -1;
                goto error;
@@ -144,7 +144,7 @@ int kernel_create_channel(struct ltt_kernel_session *session,
        struct ltt_kernel_channel *lkc;
 
        /* Allocate kernel channel */
-       lkc = trace_create_kernel_channel(chan, path);
+       lkc = trace_kernel_create_channel(chan, path);
        if (lkc == NULL) {
                goto error;
        }
@@ -187,7 +187,7 @@ int kernel_create_event(struct lttng_event *ev,
        int ret;
        struct ltt_kernel_event *event;
 
-       event = trace_create_kernel_event(ev);
+       event = trace_kernel_create_event(ev);
        if (event == NULL) {
                goto error;
        }
@@ -322,7 +322,7 @@ int kernel_open_metadata(struct ltt_kernel_session *session, char *path)
        struct ltt_kernel_metadata *lkm;
 
        /* Allocate kernel metadata */
-       lkm = trace_create_kernel_metadata(path);
+       lkm = trace_kernel_create_metadata(path);
        if (lkm == NULL) {
                goto error;
        }
@@ -474,7 +474,7 @@ int kernel_open_channel_stream(struct ltt_kernel_channel *channel)
        struct ltt_kernel_stream *lks;
 
        while ((ret = kernctl_create_stream(channel->fd)) > 0) {
-               lks = trace_create_kernel_stream();
+               lks = trace_kernel_create_stream();
                if (lks == NULL) {
                        close(ret);
                        goto error;
index a7817395316463cdd12cd291afa1c003a707ab1c..2fbaca91ef112d75a5e5289d3dbed2bc223adf80 100644 (file)
@@ -20,7 +20,7 @@
 #define _LTT_KERNEL_CTL_H
 
 #include "session.h"
-#include "trace.h"
+#include "trace-kernel.h"
 
 /*
  * Default size for the event list when kernel_list_events is called. This size
index b636986f832d7352b572c5a08fbcbaf92ceadfc7..29e05b9e9ed23cbcaf6b5c9b770caf1388a574b2 100644 (file)
@@ -182,7 +182,7 @@ static void teardown_kernel_session(struct ltt_session *session)
                        lttcomm_close_unix_sock(session->kernel_session->consumer_fd);
                }
 
-               trace_destroy_kernel_session(session->kernel_session);
+               trace_kernel_destroy_session(session->kernel_session);
                /* Extra precaution */
                session->kernel_session = NULL;
        }
@@ -1807,7 +1807,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 
                switch (cmd_ctx->lsm->domain.type) {
                case LTTNG_DOMAIN_KERNEL:
-                       kchan = get_kernel_channel_by_name(cmd_ctx->lsm->u.disable.channel_name,
+                       kchan = trace_kernel_get_channel_by_name(cmd_ctx->lsm->u.disable.channel_name,
                                        cmd_ctx->session->kernel_session);
                        if (kchan == NULL) {
                                ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
@@ -1845,14 +1845,14 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 
                switch (cmd_ctx->lsm->domain.type) {
                case LTTNG_DOMAIN_KERNEL:
-                       kchan = get_kernel_channel_by_name(cmd_ctx->lsm->u.disable.channel_name,
+                       kchan = trace_kernel_get_channel_by_name(cmd_ctx->lsm->u.disable.channel_name,
                                        cmd_ctx->session->kernel_session);
                        if (kchan == NULL) {
                                ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
                                goto error;
                        }
 
-                       kevent = get_kernel_event_by_name(cmd_ctx->lsm->u.disable.name, kchan);
+                       kevent = trace_kernel_get_event_by_name(cmd_ctx->lsm->u.disable.name, kchan);
                        if (kevent != NULL) {
                                DBG("Disabling kernel event %s for channel %s.", kevent->event->name,
                                                kchan->channel->name);
@@ -1888,7 +1888,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
                switch (cmd_ctx->lsm->domain.type) {
                case LTTNG_DOMAIN_KERNEL:
                        DBG("Disabling all enabled kernel events");
-                       kchan = get_kernel_channel_by_name(cmd_ctx->lsm->u.disable.channel_name,
+                       kchan = trace_kernel_get_channel_by_name(cmd_ctx->lsm->u.disable.channel_name,
                                        cmd_ctx->session->kernel_session);
                        if (kchan == NULL) {
                                ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
@@ -1929,7 +1929,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 
                switch (cmd_ctx->lsm->domain.type) {
                case LTTNG_DOMAIN_KERNEL:
-                       kchan = get_kernel_channel_by_name(cmd_ctx->lsm->u.enable.channel_name,
+                       kchan = trace_kernel_get_channel_by_name(cmd_ctx->lsm->u.enable.channel_name,
                                        cmd_ctx->session->kernel_session);
                        if (kchan == NULL) {
                                /* Channel not found, creating it */
@@ -1987,7 +1987,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 
                switch (cmd_ctx->lsm->domain.type) {
                case LTTNG_DOMAIN_KERNEL:
-                       kchan = get_kernel_channel_by_name(channel_name,
+                       kchan = trace_kernel_get_channel_by_name(channel_name,
                                        cmd_ctx->session->kernel_session);
                        if (kchan == NULL) {
                                DBG("Channel not found. Creating channel %s", channel_name);
@@ -2004,7 +2004,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
                                        ret = LTTCOMM_KERN_CHAN_FAIL;
                                        goto error;
                                }
-                               kchan = get_kernel_channel_by_name(channel_name,
+                               kchan = trace_kernel_get_channel_by_name(channel_name,
                                                cmd_ctx->session->kernel_session);
                                if (kchan == NULL) {
                                        ERR("Channel %s not found after creation. Internal error, giving up.",
@@ -2014,7 +2014,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
                                }
                        }
 
-                       kevent = get_kernel_event_by_name(cmd_ctx->lsm->u.enable.event.name, kchan);
+                       kevent = trace_kernel_get_event_by_name(cmd_ctx->lsm->u.enable.event.name, kchan);
                        if (kevent == NULL) {
                                DBG("Creating kernel event %s for channel %s.",
                                                cmd_ctx->lsm->u.enable.event.name, channel_name);
@@ -2065,7 +2065,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 
                switch (cmd_ctx->lsm->domain.type) {
                case LTTNG_DOMAIN_KERNEL:
-                       kchan = get_kernel_channel_by_name(channel_name,
+                       kchan = trace_kernel_get_channel_by_name(channel_name,
                                        cmd_ctx->session->kernel_session);
                        if (kchan == NULL) {
                                DBG("Channel not found. Creating channel %s", channel_name);
@@ -2082,7 +2082,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
                                        ret = LTTCOMM_KERN_CHAN_FAIL;
                                        goto error;
                                }
-                               kchan = get_kernel_channel_by_name(channel_name,
+                               kchan = trace_kernel_get_channel_by_name(channel_name,
                                                cmd_ctx->session->kernel_session);
                                if (kchan == NULL) {
                                        ERR("Channel %s not found after creation. Internal error, giving up.",
@@ -2109,7 +2109,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
                        }
 
                        for (i = 0; i < size; i++) {
-                               kevent = get_kernel_event_by_name(event_list[i].name, kchan);
+                               kevent = trace_kernel_get_event_by_name(event_list[i].name, kchan);
                                if (kevent == NULL) {
                                        /* Default event type for enable all */
                                        event_list[i].type = LTTNG_EVENT_TRACEPOINT;
@@ -2393,7 +2393,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
                struct ltt_kernel_channel *kchan = NULL;
 
                if (cmd_ctx->session->kernel_session != NULL) {
-                       kchan = get_kernel_channel_by_name(cmd_ctx->lsm->u.list.channel_name,
+                       kchan = trace_kernel_get_channel_by_name(cmd_ctx->lsm->u.list.channel_name,
                                        cmd_ctx->session->kernel_session);
                        if (kchan == NULL) {
                                ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
diff --git a/ltt-sessiond/trace-kernel.c b/ltt-sessiond/trace-kernel.c
new file mode 100644 (file)
index 0000000..3b51e31
--- /dev/null
@@ -0,0 +1,386 @@
+/*
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <lttngerr.h>
+
+#include "trace-kernel.h"
+
+/*
+ * Find the channel name for the given kernel session.
+ */
+struct ltt_kernel_channel *trace_kernel_get_channel_by_name(
+               char *name, struct ltt_kernel_session *session)
+{
+       struct ltt_kernel_channel *chan;
+
+       if (session == NULL) {
+               ERR("Undefine session");
+               goto error;
+       }
+
+       cds_list_for_each_entry(chan, &session->channel_list.head, list) {
+               if (strcmp(name, chan->channel->name) == 0) {
+                       DBG("Found channel by name %s", name);
+                       return chan;
+               }
+       }
+
+error:
+       return NULL;
+}
+
+/*
+ * Find the event name for the given channel.
+ */
+struct ltt_kernel_event *trace_kernel_get_event_by_name(
+               char *name, struct ltt_kernel_channel *channel)
+{
+       struct ltt_kernel_event *ev;
+
+       if (channel == NULL) {
+               ERR("Undefine channel");
+               goto error;
+       }
+
+       cds_list_for_each_entry(ev, &channel->events_list.head, list) {
+               if (strcmp(name, ev->event->name) == 0) {
+                       DBG("Found event by name %s for channel %s", name,
+                                       channel->channel->name);
+                       return ev;
+               }
+       }
+
+error:
+       return NULL;
+}
+
+/*
+ * Allocate and initialize a kernel session data structure.
+ *
+ * Return pointer to structure or NULL.
+ */
+struct ltt_kernel_session *trace_kernel_create_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;
+       lks->consumer_fd = 0;
+       CDS_INIT_LIST_HEAD(&lks->channel_list.head);
+
+       return lks;
+
+error:
+       return NULL;
+}
+
+/*
+ * Allocate and initialize a kernel channel data structure.
+ *
+ * Return pointer to structure or NULL.
+ */
+struct ltt_kernel_channel *trace_kernel_create_channel(struct lttng_channel *chan, char *path)
+{
+       int ret;
+       struct ltt_kernel_channel *lkc;
+
+       lkc = malloc(sizeof(struct ltt_kernel_channel));
+       if (lkc == NULL) {
+               perror("ltt_kernel_channel malloc");
+               goto error;
+       }
+
+       lkc->channel = malloc(sizeof(struct lttng_channel));
+       if (lkc->channel == NULL) {
+               perror("lttng_channel malloc");
+               goto error;
+       }
+       memcpy(lkc->channel, chan, sizeof(struct lttng_channel));
+
+       lkc->fd = 0;
+       lkc->stream_count = 0;
+       lkc->event_count = 0;
+       lkc->enabled = 1;
+       lkc->ctx = NULL;
+       /* 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", path);
+       if (ret < 0) {
+               perror("asprintf kernel create channel");
+               goto error;
+       }
+
+       return lkc;
+
+error:
+       return NULL;
+}
+
+/*
+ * Allocate and initialize a kernel event. Set name and event type.
+ *
+ * Return pointer to structure or NULL.
+ */
+struct ltt_kernel_event *trace_kernel_create_event(struct lttng_event *ev)
+{
+       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;
+       }
+
+       switch (ev->type) {
+       case LTTNG_EVENT_PROBE:
+               attr->instrumentation = LTTNG_KERNEL_KPROBE;
+               attr->u.kprobe.addr = ev->attr.probe.addr;
+               attr->u.kprobe.offset = ev->attr.probe.offset;
+               strncpy(attr->u.kprobe.symbol_name,
+                               ev->attr.probe.symbol_name, LTTNG_SYM_NAME_LEN);
+               attr->u.kprobe.symbol_name[LTTNG_SYM_NAME_LEN - 1] = '\0';
+               break;
+       case LTTNG_EVENT_FUNCTION:
+               attr->instrumentation = LTTNG_KERNEL_KRETPROBE;
+               attr->u.kretprobe.addr = ev->attr.probe.addr;
+               attr->u.kretprobe.offset = ev->attr.probe.offset;
+               attr->u.kretprobe.offset = ev->attr.probe.offset;
+               strncpy(attr->u.kretprobe.symbol_name,
+                               ev->attr.probe.symbol_name, LTTNG_SYM_NAME_LEN);
+               attr->u.kretprobe.symbol_name[LTTNG_SYM_NAME_LEN - 1] = '\0';
+               break;
+       case LTTNG_EVENT_FUNCTION_ENTRY:
+               attr->instrumentation = LTTNG_KERNEL_FUNCTION;
+               strncpy(attr->u.ftrace.symbol_name,
+                               ev->attr.ftrace.symbol_name, LTTNG_SYM_NAME_LEN);
+               attr->u.ftrace.symbol_name[LTTNG_SYM_NAME_LEN - 1] = '\0';
+               break;
+       case LTTNG_EVENT_TRACEPOINT:
+               attr->instrumentation = LTTNG_KERNEL_TRACEPOINT;
+               break;
+       default:
+               ERR("Unknown kernel instrumentation type (%d)", ev->type);
+               goto error;
+       }
+
+       /* Copy event name */
+       strncpy(attr->name, ev->name, LTTNG_SYM_NAME_LEN);
+       attr->name[LTTNG_SYM_NAME_LEN - 1] = '\0';
+
+       /* Setting up a kernel event */
+       lke->fd = 0;
+       lke->event = attr;
+       lke->enabled = 1;
+       lke->ctx = NULL;
+
+       return lke;
+
+error:
+       return NULL;
+}
+
+/*
+ * Allocate and initialize a kernel metadata.
+ *
+ * Return pointer to structure or NULL.
+ */
+struct ltt_kernel_metadata *trace_kernel_create_metadata(char *path)
+{
+       int ret;
+       struct ltt_kernel_metadata *lkm;
+       struct lttng_channel *chan;
+
+       lkm = malloc(sizeof(struct ltt_kernel_metadata));
+       chan = malloc(sizeof(struct lttng_channel));
+       if (lkm == NULL || chan == NULL) {
+               perror("kernel metadata malloc");
+               goto error;
+       }
+
+       /* Set default attributes */
+       chan->attr.overwrite = DEFAULT_CHANNEL_OVERWRITE;
+       chan->attr.subbuf_size = DEFAULT_METADATA_SUBBUF_SIZE;
+       chan->attr.num_subbuf = DEFAULT_METADATA_SUBBUF_NUM;
+       chan->attr.switch_timer_interval = DEFAULT_CHANNEL_SWITCH_TIMER;
+       chan->attr.read_timer_interval = DEFAULT_CHANNEL_READ_TIMER;
+       chan->attr.output = DEFAULT_KERNEL_CHANNEL_OUTPUT;
+
+       /* Init metadata */
+       lkm->fd = 0;
+       lkm->conf = chan;
+       /* Set default metadata path */
+       ret = asprintf(&lkm->pathname, "%s/metadata", path);
+       if (ret < 0) {
+               perror("asprintf kernel metadata");
+               goto error;
+       }
+
+       return lkm;
+
+error:
+       return NULL;
+}
+
+/*
+ * 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_kernel_create_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;
+}
+
+/*
+ * Cleanup kernel stream structure.
+ */
+void trace_kernel_destroy_stream(struct ltt_kernel_stream *stream)
+{
+       DBG("[trace] Closing stream fd %d", stream->fd);
+       /* Close kernel fd */
+       close(stream->fd);
+       free(stream->pathname);
+
+       /* Remove from stream list */
+       cds_list_del(&stream->list);
+       free(stream);
+}
+
+/*
+ * Cleanup kernel event structure.
+ */
+void trace_kernel_destroy_event(struct ltt_kernel_event *event)
+{
+       DBG("[trace] Closing event fd %d", event->fd);
+       /* Close kernel fd */
+       close(event->fd);
+       /* Free attributes */
+       free(event->event);
+
+       /* Remove from event list */
+       cds_list_del(&event->list);
+       free(event);
+}
+
+/*
+ * Cleanup kernel channel structure.
+ */
+void trace_kernel_destroy_channel(struct ltt_kernel_channel *channel)
+{
+       struct ltt_kernel_stream *stream, *stmp;
+       struct ltt_kernel_event *event, *etmp;
+
+       DBG("[trace] Closing channel fd %d", channel->fd);
+       /* Close kernel fd */
+       close(channel->fd);
+       free(channel->pathname);
+       /* Free attributes structure */
+       free(channel->channel);
+
+       /* For each stream in the channel list */
+       cds_list_for_each_entry_safe(stream, stmp, &channel->stream_list.head, list) {
+               trace_kernel_destroy_stream(stream);
+       }
+
+       /* For each event in the channel list */
+       cds_list_for_each_entry_safe(event, etmp, &channel->events_list.head, list) {
+               trace_kernel_destroy_event(event);
+       }
+
+       /* Remove from channel list */
+       cds_list_del(&channel->list);
+       free(channel);
+}
+
+/*
+ * Cleanup kernel metadata structure.
+ */
+void trace_kernel_destroy_metadata(struct ltt_kernel_metadata *metadata)
+{
+       DBG("[trace] Closing metadata fd %d", metadata->fd);
+       /* Close kernel fd */
+       close(metadata->fd);
+       /* Free attributes */
+       free(metadata->conf);
+
+       free(metadata);
+}
+
+/*
+ * Cleanup kernel session structure
+ */
+void trace_kernel_destroy_session(struct ltt_kernel_session *session)
+{
+       struct ltt_kernel_channel *channel, *ctmp;
+
+       DBG("[trace] Closing session fd %d", session->fd);
+       /* Close kernel fds */
+       close(session->fd);
+       if (session->metadata_stream_fd != 0) {
+               DBG("[trace] Closing metadata stream fd %d", session->metadata_stream_fd);
+               close(session->metadata_stream_fd);
+       }
+
+       if (session->metadata != NULL) {
+               trace_kernel_destroy_metadata(session->metadata);
+       }
+
+       cds_list_for_each_entry_safe(channel, ctmp, &session->channel_list.head, list) {
+               trace_kernel_destroy_channel(channel);
+       }
+
+       free(session);
+}
diff --git a/ltt-sessiond/trace-kernel.h b/ltt-sessiond/trace-kernel.h
new file mode 100644 (file)
index 0000000..aaadbb2
--- /dev/null
@@ -0,0 +1,121 @@
+/*
+ * 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_TRACE_KERNEL_H
+#define _LTT_TRACE_KERNEL_H
+
+#include <limits.h>
+#include <urcu/list.h>
+
+#include <lttng/lttng.h>
+#include <lttng-kernel.h>
+
+/* Kernel event list */
+struct ltt_kernel_event_list {
+       struct cds_list_head head;
+};
+
+/* Channel stream list */
+struct ltt_kernel_stream_list {
+       struct cds_list_head head;
+};
+
+/* Channel list */
+struct ltt_kernel_channel_list {
+       struct cds_list_head head;
+};
+
+/* Kernel event */
+struct ltt_kernel_event {
+       int fd;
+       int enabled;
+       struct lttng_kernel_context *ctx;
+       struct lttng_kernel_event *event;
+       struct cds_list_head list;
+};
+
+/* Kernel channel */
+struct ltt_kernel_channel {
+       int fd;
+       int enabled;
+       char *pathname;
+       unsigned int stream_count;
+       unsigned int event_count;
+       struct lttng_kernel_context *ctx;
+       struct lttng_channel *channel;
+       struct ltt_kernel_event_list events_list;
+       struct ltt_kernel_stream_list stream_list;
+       struct cds_list_head list;
+};
+
+/* Metadata */
+struct ltt_kernel_metadata {
+       int fd;
+       char *pathname;
+       struct lttng_channel *conf;
+};
+
+/* Channel stream */
+struct ltt_kernel_stream {
+       int fd;
+       char *pathname;
+       int state;
+       struct cds_list_head list;
+};
+
+/* Kernel session */
+struct ltt_kernel_session {
+       int fd;
+       int metadata_stream_fd;
+       int kconsumer_fds_sent;
+       int consumer_fd;
+       unsigned int channel_count;
+       unsigned int stream_count_global;
+       char *trace_path;
+       struct ltt_kernel_metadata *metadata;
+       struct ltt_kernel_channel_list channel_list;
+};
+
+/*
+ * Lookup functions. NULL is returned if not found.
+ */
+struct ltt_kernel_event *trace_kernel_get_event_by_name(
+               char *name, struct ltt_kernel_channel *channel);
+struct ltt_kernel_channel *trace_kernel_get_channel_by_name(
+               char *name, struct ltt_kernel_session *session);
+
+/*
+ * Create functions malloc() the data structure.
+ */
+struct ltt_kernel_session *trace_kernel_create_session(void);
+struct ltt_kernel_channel *trace_kernel_create_channel(struct lttng_channel *chan, char *path);
+struct ltt_kernel_event *trace_kernel_create_event(struct lttng_event *ev);
+struct ltt_kernel_metadata *trace_kernel_create_metadata(char *path);
+struct ltt_kernel_stream *trace_kernel_create_stream(void);
+
+/*
+ * Destroy functions free() the data structure and remove from linked list if
+ * it's applies.
+ */
+void trace_kernel_destroy_session(struct ltt_kernel_session *session);
+void trace_kernel_destroy_metadata(struct ltt_kernel_metadata *metadata);
+void trace_kernel_destroy_channel(struct ltt_kernel_channel *channel);
+void trace_kernel_destroy_event(struct ltt_kernel_event *event);
+void trace_kernel_destroy_stream(struct ltt_kernel_stream *stream);
+
+#endif /* _LTT_TRACE_KERNEL_H */
diff --git a/ltt-sessiond/trace.c b/ltt-sessiond/trace.c
deleted file mode 100644 (file)
index 8b123a7..0000000
+++ /dev/null
@@ -1,386 +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 <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include <lttngerr.h>
-
-#include "trace.h"
-
-/*
- * Find the channel name for the given kernel session.
- */
-struct ltt_kernel_channel *get_kernel_channel_by_name(
-               char *name, struct ltt_kernel_session *session)
-{
-       struct ltt_kernel_channel *chan;
-
-       if (session == NULL) {
-               ERR("Undefine session");
-               goto error;
-       }
-
-       cds_list_for_each_entry(chan, &session->channel_list.head, list) {
-               if (strcmp(name, chan->channel->name) == 0) {
-                       DBG("Found channel by name %s", name);
-                       return chan;
-               }
-       }
-
-error:
-       return NULL;
-}
-
-/*
- * Find the event name for the given channel.
- */
-struct ltt_kernel_event *get_kernel_event_by_name(
-               char *name, struct ltt_kernel_channel *channel)
-{
-       struct ltt_kernel_event *ev;
-
-       if (channel == NULL) {
-               ERR("Undefine channel");
-               goto error;
-       }
-
-       cds_list_for_each_entry(ev, &channel->events_list.head, list) {
-               if (strcmp(name, ev->event->name) == 0) {
-                       DBG("Found event by name %s for channel %s", name,
-                                       channel->channel->name);
-                       return ev;
-               }
-       }
-
-error:
-       return NULL;
-}
-
-/*
- * 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;
-       lks->consumer_fd = 0;
-       CDS_INIT_LIST_HEAD(&lks->channel_list.head);
-
-       return lks;
-
-error:
-       return NULL;
-}
-
-/*
- * Allocate and initialize a kernel channel data structure.
- *
- * Return pointer to structure or NULL.
- */
-struct ltt_kernel_channel *trace_create_kernel_channel(struct lttng_channel *chan, char *path)
-{
-       int ret;
-       struct ltt_kernel_channel *lkc;
-
-       lkc = malloc(sizeof(struct ltt_kernel_channel));
-       if (lkc == NULL) {
-               perror("ltt_kernel_channel malloc");
-               goto error;
-       }
-
-       lkc->channel = malloc(sizeof(struct lttng_channel));
-       if (lkc->channel == NULL) {
-               perror("lttng_channel malloc");
-               goto error;
-       }
-       memcpy(lkc->channel, chan, sizeof(struct lttng_channel));
-
-       lkc->fd = 0;
-       lkc->stream_count = 0;
-       lkc->event_count = 0;
-       lkc->enabled = 1;
-       lkc->ctx = NULL;
-       /* 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", path);
-       if (ret < 0) {
-               perror("asprintf kernel create channel");
-               goto error;
-       }
-
-       return lkc;
-
-error:
-       return NULL;
-}
-
-/*
- * 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(struct lttng_event *ev)
-{
-       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;
-       }
-
-       switch (ev->type) {
-       case LTTNG_EVENT_PROBE:
-               attr->instrumentation = LTTNG_KERNEL_KPROBE;
-               attr->u.kprobe.addr = ev->attr.probe.addr;
-               attr->u.kprobe.offset = ev->attr.probe.offset;
-               strncpy(attr->u.kprobe.symbol_name,
-                               ev->attr.probe.symbol_name, LTTNG_SYM_NAME_LEN);
-               attr->u.kprobe.symbol_name[LTTNG_SYM_NAME_LEN - 1] = '\0';
-               break;
-       case LTTNG_EVENT_FUNCTION:
-               attr->instrumentation = LTTNG_KERNEL_KRETPROBE;
-               attr->u.kretprobe.addr = ev->attr.probe.addr;
-               attr->u.kretprobe.offset = ev->attr.probe.offset;
-               attr->u.kretprobe.offset = ev->attr.probe.offset;
-               strncpy(attr->u.kretprobe.symbol_name,
-                               ev->attr.probe.symbol_name, LTTNG_SYM_NAME_LEN);
-               attr->u.kretprobe.symbol_name[LTTNG_SYM_NAME_LEN - 1] = '\0';
-               break;
-       case LTTNG_EVENT_FUNCTION_ENTRY:
-               attr->instrumentation = LTTNG_KERNEL_FUNCTION;
-               strncpy(attr->u.ftrace.symbol_name,
-                               ev->attr.ftrace.symbol_name, LTTNG_SYM_NAME_LEN);
-               attr->u.ftrace.symbol_name[LTTNG_SYM_NAME_LEN - 1] = '\0';
-               break;
-       case LTTNG_EVENT_TRACEPOINT:
-               attr->instrumentation = LTTNG_KERNEL_TRACEPOINT;
-               break;
-       default:
-               ERR("Unknown kernel instrumentation type (%d)", ev->type);
-               goto error;
-       }
-
-       /* Copy event name */
-       strncpy(attr->name, ev->name, LTTNG_SYM_NAME_LEN);
-       attr->name[LTTNG_SYM_NAME_LEN - 1] = '\0';
-
-       /* Setting up a kernel event */
-       lke->fd = 0;
-       lke->event = attr;
-       lke->enabled = 1;
-       lke->ctx = NULL;
-
-       return lke;
-
-error:
-       return NULL;
-}
-
-/*
- * Allocate and initialize a kernel metadata.
- *
- * Return pointer to structure or NULL.
- */
-struct ltt_kernel_metadata *trace_create_kernel_metadata(char *path)
-{
-       int ret;
-       struct ltt_kernel_metadata *lkm;
-       struct lttng_channel *chan;
-
-       lkm = malloc(sizeof(struct ltt_kernel_metadata));
-       chan = malloc(sizeof(struct lttng_channel));
-       if (lkm == NULL || chan == NULL) {
-               perror("kernel metadata malloc");
-               goto error;
-       }
-
-       /* Set default attributes */
-       chan->attr.overwrite = DEFAULT_CHANNEL_OVERWRITE;
-       chan->attr.subbuf_size = DEFAULT_METADATA_SUBBUF_SIZE;
-       chan->attr.num_subbuf = DEFAULT_METADATA_SUBBUF_NUM;
-       chan->attr.switch_timer_interval = DEFAULT_CHANNEL_SWITCH_TIMER;
-       chan->attr.read_timer_interval = DEFAULT_CHANNEL_READ_TIMER;
-       chan->attr.output = DEFAULT_KERNEL_CHANNEL_OUTPUT;
-
-       /* Init metadata */
-       lkm->fd = 0;
-       lkm->conf = chan;
-       /* Set default metadata path */
-       ret = asprintf(&lkm->pathname, "%s/metadata", path);
-       if (ret < 0) {
-               perror("asprintf kernel metadata");
-               goto error;
-       }
-
-       return lkm;
-
-error:
-       return NULL;
-}
-
-/*
- * 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;
-}
-
-/*
- * Cleanup kernel stream structure.
- */
-void trace_destroy_kernel_stream(struct ltt_kernel_stream *stream)
-{
-       DBG("[trace] Closing stream fd %d", stream->fd);
-       /* Close kernel fd */
-       close(stream->fd);
-       free(stream->pathname);
-
-       /* Remove from stream list */
-       cds_list_del(&stream->list);
-       free(stream);
-}
-
-/*
- * Cleanup kernel event structure.
- */
-void trace_destroy_kernel_event(struct ltt_kernel_event *event)
-{
-       DBG("[trace] Closing event fd %d", event->fd);
-       /* Close kernel fd */
-       close(event->fd);
-       /* Free attributes */
-       free(event->event);
-
-       /* Remove from event list */
-       cds_list_del(&event->list);
-       free(event);
-}
-
-/*
- * Cleanup kernel channel structure.
- */
-void trace_destroy_kernel_channel(struct ltt_kernel_channel *channel)
-{
-       struct ltt_kernel_stream *stream, *stmp;
-       struct ltt_kernel_event *event, *etmp;
-
-       DBG("[trace] Closing channel fd %d", channel->fd);
-       /* Close kernel fd */
-       close(channel->fd);
-       free(channel->pathname);
-       /* Free attributes structure */
-       free(channel->channel);
-
-       /* For each stream in the channel list */
-       cds_list_for_each_entry_safe(stream, stmp, &channel->stream_list.head, list) {
-               trace_destroy_kernel_stream(stream);
-       }
-
-       /* For each event in the channel list */
-       cds_list_for_each_entry_safe(event, etmp, &channel->events_list.head, list) {
-               trace_destroy_kernel_event(event);
-       }
-
-       /* Remove from channel list */
-       cds_list_del(&channel->list);
-       free(channel);
-}
-
-/*
- * Cleanup kernel metadata structure.
- */
-void trace_destroy_kernel_metadata(struct ltt_kernel_metadata *metadata)
-{
-       DBG("[trace] Closing metadata fd %d", metadata->fd);
-       /* Close kernel fd */
-       close(metadata->fd);
-       /* Free attributes */
-       free(metadata->conf);
-
-       free(metadata);
-}
-
-/*
- * Cleanup kernel session structure 
- */
-void trace_destroy_kernel_session(struct ltt_kernel_session *session)
-{
-       struct ltt_kernel_channel *channel, *ctmp;
-
-       DBG("[trace] Closing session fd %d", session->fd);
-       /* Close kernel fds */
-       close(session->fd);
-       if (session->metadata_stream_fd != 0) {
-               DBG("[trace] Closing metadata stream fd %d", session->metadata_stream_fd);
-               close(session->metadata_stream_fd);
-       }
-
-       if (session->metadata != NULL) {
-               trace_destroy_kernel_metadata(session->metadata);
-       }
-
-       cds_list_for_each_entry_safe(channel, ctmp, &session->channel_list.head, list) {
-               trace_destroy_kernel_channel(channel);
-       }
-
-       free(session);
-}
diff --git a/ltt-sessiond/trace.h b/ltt-sessiond/trace.h
deleted file mode 100644 (file)
index 6fd36d6..0000000
+++ /dev/null
@@ -1,133 +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_TRACE_H
-#define _LTT_TRACE_H
-
-#include <limits.h>
-#include <urcu/list.h>
-
-#include <lttng/lttng.h>
-#include <lttng-kernel.h>
-
-/* Kernel event list */
-struct ltt_kernel_event_list {
-       struct cds_list_head head;
-};
-
-/* Channel stream list */
-struct ltt_kernel_stream_list {
-       struct cds_list_head head;
-};
-
-/* Channel list */
-struct ltt_kernel_channel_list {
-       struct cds_list_head head;
-};
-
-/* Kernel event */
-struct ltt_kernel_event {
-       int fd;
-       int enabled;
-       struct lttng_kernel_context *ctx;
-       struct lttng_kernel_event *event;
-       struct cds_list_head list;
-};
-
-/* Kernel channel */
-struct ltt_kernel_channel {
-       int fd;
-       int enabled;
-       char *pathname;
-       unsigned int stream_count;
-       unsigned int event_count;
-       struct lttng_kernel_context *ctx;
-       struct lttng_channel *channel;
-       struct ltt_kernel_event_list events_list;
-       struct ltt_kernel_stream_list stream_list;
-       struct cds_list_head list;
-};
-
-/* Metadata */
-struct ltt_kernel_metadata {
-       int fd;
-       char *pathname;
-       struct lttng_channel *conf;
-};
-
-/* Channel stream */
-struct ltt_kernel_stream {
-       int fd;
-       char *pathname;
-       int state;
-       struct cds_list_head list;
-};
-
-/* Kernel session */
-struct ltt_kernel_session {
-       int fd;
-       int metadata_stream_fd;
-       int kconsumer_fds_sent;
-       int consumer_fd;
-       unsigned int channel_count;
-       unsigned int stream_count_global;
-       char *trace_path;
-       struct ltt_kernel_metadata *metadata;
-       struct ltt_kernel_channel_list channel_list;
-};
-
-/* UST trace representation */
-struct ltt_ust_trace {
-       struct cds_list_head list;
-       char name[NAME_MAX];
-       int shmid;
-       pid_t pid;
-       struct cds_list_head markers;
-};
-
-struct ltt_ust_marker {
-       struct cds_list_head list;
-       char *name;
-       char *channel;
-};
-
-struct ltt_kernel_event *get_kernel_event_by_name(
-               char *name, struct ltt_kernel_channel *channel);
-struct ltt_kernel_channel *get_kernel_channel_by_name(
-               char *name, struct ltt_kernel_session *session);
-
-/*
- * Create functions malloc() the data structure.
- */
-struct ltt_kernel_session *trace_create_kernel_session(void);
-struct ltt_kernel_channel *trace_create_kernel_channel(struct lttng_channel *chan, char *path);
-struct ltt_kernel_event *trace_create_kernel_event(struct lttng_event *ev);
-struct ltt_kernel_metadata *trace_create_kernel_metadata(char *path);
-struct ltt_kernel_stream *trace_create_kernel_stream(void);
-
-/*
- * Destroy functions free() the data structure and remove from linked list if
- * it's applies.
- */
-void trace_destroy_kernel_session(struct ltt_kernel_session *session);
-void trace_destroy_kernel_metadata(struct ltt_kernel_metadata *metadata);
-void trace_destroy_kernel_channel(struct ltt_kernel_channel *channel);
-void trace_destroy_kernel_event(struct ltt_kernel_event *event);
-void trace_destroy_kernel_stream(struct ltt_kernel_stream *stream);
-
-#endif /* _LTT_TRACE_H */
index b864c0802983e329980229d1f367cd316bb94e2c..6ec5fbdc4080f0708c2e66862b293cb895925be1 100644 (file)
 #ifndef _LTT_UST_CTL_H
 #define _LTT_UST_CTL_H
 
-#include "session.h"
-#include "trace.h"
-
-/*
-int get_trace_count_per_session(struct ltt_session *session);
-void get_traces_per_session(struct ltt_session *session, struct lttng_trace *traces);
-int ust_create_trace(struct command_ctx *cmd_ctx);
-int ust_start_trace(struct command_ctx *cmd_ctx);
-int ust_stop_trace(struct command_ctx *cmd_ctx);
-*/
-
-#endif /* _LTT_TRACE_H */
+#endif /* _LTT_UST_CTL_H */
This page took 0.064217 seconds and 4 git commands to generate.