X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=ltt-sessiond%2Ftrace.c;h=0ae80adbc465e49ba270cfc5f7268ffec0eab9a6;hp=eb7d0e152497569634e5fbf094d2a8d7170e9cbe;hb=050349bbb362ea993533591532643022efeab864;hpb=19e708528b7ebd740485ca05056e56e6835d43a7 diff --git a/ltt-sessiond/trace.c b/ltt-sessiond/trace.c index eb7d0e152..0ae80adbc 100644 --- a/ltt-sessiond/trace.c +++ b/ltt-sessiond/trace.c @@ -3,8 +3,8 @@ * * 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. + * 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 @@ -24,13 +24,10 @@ #include #include "lttngerr.h" -#include "ltt-sessiond.h" #include "trace.h" /* - * get_kernel_channel_by_name - * - * Find the channel name for the given kernel session. + * 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) @@ -54,9 +51,7 @@ error: } /* - * get_kernel_event_by_name - * - * Find the event name for the given channel. + * Find the event name for the given channel. */ struct ltt_kernel_event *get_kernel_event_by_name( char *name, struct ltt_kernel_channel *channel) @@ -81,11 +76,9 @@ error: } /* - * trace_create_kernel_session - * - * Allocate and initialize a kernel session data structure. + * Allocate and initialize a kernel session data structure. * - * Return pointer to structure or NULL. + * Return pointer to structure or NULL. */ struct ltt_kernel_session *trace_create_kernel_session(void) { @@ -104,6 +97,7 @@ struct ltt_kernel_session *trace_create_kernel_session(void) 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; @@ -113,13 +107,11 @@ error: } /* - * trace_create_kernel_channel + * Allocate and initialize a kernel channel data structure. * - * Allocate and initialize a kernel channel data structure. - * - * Return pointer to structure or NULL. + * Return pointer to structure or NULL. */ -struct ltt_kernel_channel *trace_create_kernel_channel(struct lttng_channel *chan) +struct ltt_kernel_channel *trace_create_kernel_channel(struct lttng_channel *chan, char *path) { int ret; struct ltt_kernel_channel *lkc; @@ -139,11 +131,14 @@ struct ltt_kernel_channel *trace_create_kernel_channel(struct lttng_channel *cha 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", DEFAULT_TRACE_OUTPUT); + ret = asprintf(&lkc->pathname, "%s", path); if (ret < 0) { perror("asprintf kernel create channel"); goto error; @@ -156,11 +151,9 @@ error: } /* - * trace_create_kernel_event - * - * Allocate and initialize a kernel event. Set name and event type. + * Allocate and initialize a kernel event. Set name and event type. * - * Return pointer to structure or NULL. + * Return pointer to structure or NULL. */ struct ltt_kernel_event *trace_create_kernel_event(struct lttng_event *ev) { @@ -175,20 +168,31 @@ struct ltt_kernel_event *trace_create_kernel_event(struct lttng_event *ev) } switch (ev->type) { - case LTTNG_EVENT_KPROBES: - attr->instrumentation = LTTNG_KERNEL_KPROBES; - attr->u.kprobe.addr = ev->attr.kprobe.addr; - attr->u.kprobe.offset = ev->attr.kprobe.offset; + 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.kprobe.symbol_name, LTTNG_SYM_NAME_LEN); + 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_TRACEPOINTS: - attr->instrumentation = LTTNG_KERNEL_TRACEPOINTS; + case LTTNG_EVENT_TRACEPOINT: + attr->instrumentation = LTTNG_KERNEL_TRACEPOINT; break; default: ERR("Unknown kernel instrumentation type (%d)", ev->type); @@ -197,10 +201,13 @@ struct ltt_kernel_event *trace_create_kernel_event(struct lttng_event *ev) /* 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; @@ -209,13 +216,11 @@ error: } /* - * trace_create_kernel_metadata - * - * Allocate and initialize a kernel metadata. + * Allocate and initialize a kernel metadata. * - * Return pointer to structure or NULL. + * Return pointer to structure or NULL. */ -struct ltt_kernel_metadata *trace_create_kernel_metadata(void) +struct ltt_kernel_metadata *trace_create_kernel_metadata(char *path) { int ret; struct ltt_kernel_metadata *lkm; @@ -230,16 +235,17 @@ struct ltt_kernel_metadata *trace_create_kernel_metadata(void) /* Set default attributes */ chan->attr.overwrite = DEFAULT_CHANNEL_OVERWRITE; - chan->attr.subbuf_size = DEFAULT_CHANNEL_SUBBUF_SIZE; - chan->attr.num_subbuf = DEFAULT_CHANNEL_SUBBUF_NUM; + 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", DEFAULT_TRACE_OUTPUT); + ret = asprintf(&lkm->pathname, "%s/metadata", path); if (ret < 0) { perror("asprintf kernel metadata"); goto error; @@ -252,12 +258,10 @@ error: } /* - * trace_create_kernel_stream - * - * Allocate and initialize a kernel stream. The stream is set to ACTIVE_FD by - * default. + * Allocate and initialize a kernel stream. The stream is set to ACTIVE_FD by + * default. * - * Return pointer to structure or NULL. + * Return pointer to structure or NULL. */ struct ltt_kernel_stream *trace_create_kernel_stream(void) { @@ -280,6 +284,9 @@ 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); @@ -292,6 +299,9 @@ void trace_destroy_kernel_stream(struct ltt_kernel_stream *stream) free(stream); } +/* + * Cleanup kernel event structure. + */ void trace_destroy_kernel_event(struct ltt_kernel_event *event) { DBG("[trace] Closing event fd %d", event->fd); @@ -305,10 +315,13 @@ void trace_destroy_kernel_event(struct ltt_kernel_event *event) free(event); } +/* + * Cleanup kernel channel structure. + */ void trace_destroy_kernel_channel(struct ltt_kernel_channel *channel) { - struct ltt_kernel_stream *stream; - struct ltt_kernel_event *event; + struct ltt_kernel_stream *stream, *stmp; + struct ltt_kernel_event *event, *etmp; DBG("[trace] Closing channel fd %d", channel->fd); /* Close kernel fd */ @@ -318,12 +331,12 @@ void trace_destroy_kernel_channel(struct ltt_kernel_channel *channel) free(channel->channel); /* For each stream in the channel list */ - cds_list_for_each_entry(stream, &channel->stream_list.head, 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(event, &channel->events_list.head, list) { + cds_list_for_each_entry_safe(event, etmp, &channel->events_list.head, list) { trace_destroy_kernel_event(event); } @@ -332,6 +345,9 @@ void trace_destroy_kernel_channel(struct ltt_kernel_channel *channel) free(channel); } +/* + * Cleanup kernel metadata structure. + */ void trace_destroy_kernel_metadata(struct ltt_kernel_metadata *metadata) { DBG("[trace] Closing metadata fd %d", metadata->fd); @@ -343,9 +359,12 @@ void trace_destroy_kernel_metadata(struct ltt_kernel_metadata *metadata) free(metadata); } +/* + * Cleanup kernel session structure + */ void trace_destroy_kernel_session(struct ltt_kernel_session *session) { - struct ltt_kernel_channel *channel; + struct ltt_kernel_channel *channel, *ctmp; DBG("[trace] Closing session fd %d", session->fd); /* Close kernel fds */ @@ -355,9 +374,11 @@ void trace_destroy_kernel_session(struct ltt_kernel_session *session) close(session->metadata_stream_fd); } - trace_destroy_kernel_metadata(session->metadata); + if (session->metadata != NULL) { + trace_destroy_kernel_metadata(session->metadata); + } - cds_list_for_each_entry(channel, &session->channel_list.head, list) { + cds_list_for_each_entry_safe(channel, ctmp, &session->channel_list.head, list) { trace_destroy_kernel_channel(channel); }