From 540126381ff8f3b1e2b3357329fe105fc0bb5e4c Mon Sep 17 00:00:00 2001 From: David Goulet Date: Fri, 27 May 2011 13:54:12 -0400 Subject: [PATCH] Add kernel trace data structure init functions 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 --- ltt-sessiond/Makefile.am | 2 +- ltt-sessiond/kernel-ctl.c | 134 ++++++++--------------- ltt-sessiond/ltt-sessiond.h | 5 - ltt-sessiond/trace.c | 209 ++++++++++++++++++++++++++++++++++++ ltt-sessiond/trace.h | 27 +++++ 5 files changed, 282 insertions(+), 95 deletions(-) create mode 100644 ltt-sessiond/trace.c diff --git a/ltt-sessiond/Makefile.am b/ltt-sessiond/Makefile.am index 4d634a90a..b7200064f 100644 --- a/ltt-sessiond/Makefile.am +++ b/ltt-sessiond/Makefile.am @@ -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 \ diff --git a/ltt-sessiond/kernel-ctl.c b/ltt-sessiond/kernel-ctl.c index 352dabbb0..a4d8099f9 100644 --- a/ltt-sessiond/kernel-ctl.c +++ b/ltt-sessiond/kernel-ctl.c @@ -31,33 +31,31 @@ /* * 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; } diff --git a/ltt-sessiond/ltt-sessiond.h b/ltt-sessiond/ltt-sessiond.h index 161da0d8e..af48cd92a 100644 --- a/ltt-sessiond/ltt-sessiond.h +++ b/ltt-sessiond/ltt-sessiond.h @@ -28,11 +28,6 @@ * 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 index 000000000..8b1d15e10 --- /dev/null +++ b/ltt-sessiond/trace.c @@ -0,0 +1,209 @@ +/* + * Copyright (C) 2011 - David Goulet + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; 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 +#include +#include +#include + +#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; +} diff --git a/ltt-sessiond/trace.h b/ltt-sessiond/trace.h index f0d25c894..488fd757d 100644 --- a/ltt-sessiond/trace.h +++ b/ltt-sessiond/trace.h @@ -23,6 +23,13 @@ #include #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 */ -- 2.34.1