[lttng-tools.git] / src / bin / lttng-sessiond / trace-kernel.c

/*
 * 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 <common/common.h>
#include <common/defaults.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;
	}

	DBG("Trying to find channel %s", name);

	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(char *path)
{
	int ret;
	struct ltt_kernel_session *lks;

	/* Allocate a new ltt kernel session */
	lks = zmalloc(sizeof(struct ltt_kernel_session));
	if (lks == NULL) {
		perror("create kernel session zmalloc");
		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);

	/* Set session path */
	ret = asprintf(&lks->trace_path, "%s/kernel", path);
	if (ret < 0) {
		perror("asprintf kernel traces path");
		goto error;
	}

	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 = zmalloc(sizeof(struct ltt_kernel_channel));
	if (lkc == NULL) {
		perror("ltt_kernel_channel zmalloc");
		goto error;
	}

	lkc->channel = zmalloc(sizeof(struct lttng_channel));
	if (lkc->channel == NULL) {
		perror("lttng_channel zmalloc");
		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 = zmalloc(sizeof(struct ltt_kernel_event));
	attr = zmalloc(sizeof(struct lttng_kernel_event));
	if (lke == NULL || attr == NULL) {
		perror("kernel event zmalloc");
		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_KERNEL_SYM_NAME_LEN);
		attr->u.kprobe.symbol_name[LTTNG_KERNEL_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_KERNEL_SYM_NAME_LEN);
		attr->u.kretprobe.symbol_name[LTTNG_KERNEL_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_KERNEL_SYM_NAME_LEN);
		attr->u.ftrace.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
		break;
	case LTTNG_EVENT_TRACEPOINT:
		attr->instrumentation = LTTNG_KERNEL_TRACEPOINT;
		break;
	case LTTNG_EVENT_SYSCALL:
		attr->instrumentation = LTTNG_KERNEL_SYSCALL;
		break;
	case LTTNG_EVENT_ALL:
		attr->instrumentation = LTTNG_KERNEL_ALL;
		break;
	default:
		ERR("Unknown kernel instrumentation type (%d)", ev->type);
		goto error;
	}

	/* Copy event name */
	strncpy(attr->name, ev->name, LTTNG_KERNEL_SYM_NAME_LEN);
	attr->name[LTTNG_KERNEL_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 = zmalloc(sizeof(struct ltt_kernel_metadata));
	chan = zmalloc(sizeof(struct lttng_channel));
	if (lkm == NULL || chan == NULL) {
		perror("kernel metadata zmalloc");
		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 = zmalloc(sizeof(struct ltt_kernel_stream));
	if (lks == NULL) {
		perror("kernel stream zmalloc");
		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);
	/* Remove from stream list */
	cds_list_del(&stream->list);

	free(stream->pathname);
	free(stream);
}

/*
 * Cleanup kernel event structure.
 */
void trace_kernel_destroy_event(struct ltt_kernel_event *event)
{
	if (event->fd >= 0) {
		DBG("[trace] Closing event fd %d", event->fd);
		/* Close kernel fd */
		close(event->fd);
	} else {
		DBG("[trace] Tearing down event (no associated fd)");
	}

	/* Remove from event list */
	cds_list_del(&event->list);

	free(event->event);
	free(event->ctx);
	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);

	/* 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->pathname);
	free(channel->channel);
	free(channel->ctx);
	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(metadata->conf);
	free(metadata->pathname);
	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->trace_path);
	free(session);
}
Commit	Line	Data
54012638 DG	1	/*
	2	* Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
82a3637f DG	6	* as published by the Free Software Foundation; only version 2
82a3637f DG	7	* of the License.
54012638 DG	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	17	*/
	18
	19	#define _GNU_SOURCE
	20	#include <stdio.h>
	21	#include <stdlib.h>
	22	#include <string.h>
c363b55d	23	#include <unistd.h>
54012638	24
990570ed DG	25	#include <common/common.h>
990570ed DG	26	#include <common/defaults.h>
1e307fab	27
62499ad6	28	#include "trace-kernel.h"
54012638	29
19e70852	30	/*
050349bb	31	* Find the channel name for the given kernel session.
19e70852	32	*/
62499ad6	33	struct ltt_kernel_channel *trace_kernel_get_channel_by_name(
19e70852 DG	34	char name, struct ltt_kernel_session session)
	35	{
	36	struct ltt_kernel_channel *chan;
	37
	38	if (session == NULL) {
	39	ERR("Undefine session");
	40	goto error;
	41	}
	42
54d01ffb DG	43	DBG("Trying to find channel %s", name);
54d01ffb DG	44
19e70852 DG	45	cds_list_for_each_entry(chan, &session->channel_list.head, list) {
	46	if (strcmp(name, chan->channel->name) == 0) {
	47	DBG("Found channel by name %s", name);
	48	return chan;
	49	}
	50	}
	51
	52	error:
	53	return NULL;
	54	}
	55
	56	/*
050349bb	57	* Find the event name for the given channel.
19e70852	58	*/
62499ad6	59	struct ltt_kernel_event *trace_kernel_get_event_by_name(
19e70852 DG	60	char name, struct ltt_kernel_channel channel)
	61	{
	62	struct ltt_kernel_event *ev;
	63
	64	if (channel == NULL) {
	65	ERR("Undefine channel");
	66	goto error;
	67	}
	68
	69	cds_list_for_each_entry(ev, &channel->events_list.head, list) {
	70	if (strcmp(name, ev->event->name) == 0) {
	71	DBG("Found event by name %s for channel %s", name,
	72	channel->channel->name);
	73	return ev;
	74	}
	75	}
	76
	77	error:
	78	return NULL;
	79	}
	80
54012638	81	/*
050349bb	82	* Allocate and initialize a kernel session data structure.
54012638	83	*
050349bb	84	* Return pointer to structure or NULL.
54012638	85	*/
f9815039	86	struct ltt_kernel_session trace_kernel_create_session(char path)
54012638	87	{
f9815039	88	int ret;
54012638 DG	89	struct ltt_kernel_session *lks;
	90
	91	/* Allocate a new ltt kernel session */
ba7f0ae5	92	lks = zmalloc(sizeof(struct ltt_kernel_session));
54012638	93	if (lks == NULL) {
ba7f0ae5	94	perror("create kernel session zmalloc");
54012638 DG	95	goto error;
	96	}
	97
	98	/* Init data structure */
	99	lks->fd = 0;
	100	lks->metadata_stream_fd = 0;
	101	lks->channel_count = 0;
	102	lks->stream_count_global = 0;
	103	lks->metadata = NULL;
d9800920	104	lks->consumer_fd = 0;
54012638 DG	105	CDS_INIT_LIST_HEAD(&lks->channel_list.head);
54012638 DG	106
f9815039 DG	107	/* Set session path */
	108	ret = asprintf(&lks->trace_path, "%s/kernel", path);
	109	if (ret < 0) {
	110	perror("asprintf kernel traces path");
	111	goto error;
	112	}
	113
54012638 DG	114	return lks;
	115
	116	error:
	117	return NULL;
	118	}
	119
	120	/*
050349bb	121	* Allocate and initialize a kernel channel data structure.
54012638	122	*
050349bb	123	* Return pointer to structure or NULL.
54012638	124	*/
62499ad6	125	struct ltt_kernel_channel trace_kernel_create_channel(struct lttng_channel chan, char *path)
54012638 DG	126	{
	127	int ret;
	128	struct ltt_kernel_channel *lkc;
54012638	129
ba7f0ae5	130	lkc = zmalloc(sizeof(struct ltt_kernel_channel));
f3ed775e	131	if (lkc == NULL) {
ba7f0ae5	132	perror("ltt_kernel_channel zmalloc");
54012638 DG	133	goto error;
	134	}
	135
ba7f0ae5	136	lkc->channel = zmalloc(sizeof(struct lttng_channel));
f3ed775e	137	if (lkc->channel == NULL) {
ba7f0ae5	138	perror("lttng_channel zmalloc");
f3ed775e DG	139	goto error;
	140	}
	141	memcpy(lkc->channel, chan, sizeof(struct lttng_channel));
54012638 DG	142
	143	lkc->fd = 0;
	144	lkc->stream_count = 0;
cbbbb275	145	lkc->event_count = 0;
d36b8583	146	lkc->enabled = 1;
e75cda3a	147	lkc->ctx = NULL;
54012638 DG	148	/* Init linked list */
	149	CDS_INIT_LIST_HEAD(&lkc->events_list.head);
	150	CDS_INIT_LIST_HEAD(&lkc->stream_list.head);
	151	/* Set default trace output path */
b082db07	152	ret = asprintf(&lkc->pathname, "%s", path);
54012638 DG	153	if (ret < 0) {
	154	perror("asprintf kernel create channel");
	155	goto error;
	156	}
	157
	158	return lkc;
	159
	160	error:
	161	return NULL;
	162	}
	163
	164	/*
050349bb	165	* Allocate and initialize a kernel event. Set name and event type.
54012638	166	*
050349bb	167	* Return pointer to structure or NULL.
54012638	168	*/
62499ad6	169	struct ltt_kernel_event trace_kernel_create_event(struct lttng_event ev)
54012638 DG	170	{
	171	struct ltt_kernel_event *lke;
	172	struct lttng_kernel_event *attr;
	173
ba7f0ae5 DG	174	lke = zmalloc(sizeof(struct ltt_kernel_event));
ba7f0ae5 DG	175	attr = zmalloc(sizeof(struct lttng_kernel_event));
54012638	176	if (lke == NULL \|\| attr == NULL) {
ba7f0ae5	177	perror("kernel event zmalloc");
54012638 DG	178	goto error;
	179	}
	180
f3ed775e	181	switch (ev->type) {
7d29a247	182	case LTTNG_EVENT_PROBE:
e6ddca71	183	attr->instrumentation = LTTNG_KERNEL_KPROBE;
7d29a247 DG	184	attr->u.kprobe.addr = ev->attr.probe.addr;
7d29a247 DG	185	attr->u.kprobe.offset = ev->attr.probe.offset;
f3ed775e	186	strncpy(attr->u.kprobe.symbol_name,
dbbb3ec5 DG	187	ev->attr.probe.symbol_name, LTTNG_KERNEL_SYM_NAME_LEN);
dbbb3ec5 DG	188	attr->u.kprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
f3ed775e DG	189	break;
f3ed775e DG	190	case LTTNG_EVENT_FUNCTION:
8f0d098b MD	191	attr->instrumentation = LTTNG_KERNEL_KRETPROBE;
	192	attr->u.kretprobe.addr = ev->attr.probe.addr;
	193	attr->u.kretprobe.offset = ev->attr.probe.offset;
	194	attr->u.kretprobe.offset = ev->attr.probe.offset;
	195	strncpy(attr->u.kretprobe.symbol_name,
dbbb3ec5 DG	196	ev->attr.probe.symbol_name, LTTNG_KERNEL_SYM_NAME_LEN);
dbbb3ec5 DG	197	attr->u.kretprobe.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
8f0d098b MD	198	break;
8f0d098b MD	199	case LTTNG_EVENT_FUNCTION_ENTRY:
f3ed775e DG	200	attr->instrumentation = LTTNG_KERNEL_FUNCTION;
f3ed775e DG	201	strncpy(attr->u.ftrace.symbol_name,
dbbb3ec5 DG	202	ev->attr.ftrace.symbol_name, LTTNG_KERNEL_SYM_NAME_LEN);
dbbb3ec5 DG	203	attr->u.ftrace.symbol_name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
f3ed775e	204	break;
e6ddca71 DG	205	case LTTNG_EVENT_TRACEPOINT:
e6ddca71 DG	206	attr->instrumentation = LTTNG_KERNEL_TRACEPOINT;
f3ed775e	207	break;
a54bd42d MD	208	case LTTNG_EVENT_SYSCALL:
a54bd42d MD	209	attr->instrumentation = LTTNG_KERNEL_SYSCALL;
0133c199	210	break;
7a3d1328 MD	211	case LTTNG_EVENT_ALL:
	212	attr->instrumentation = LTTNG_KERNEL_ALL;
	213	break;
f3ed775e DG	214	default:
	215	ERR("Unknown kernel instrumentation type (%d)", ev->type);
	216	goto error;
	217	}
	218
	219	/* Copy event name */
dbbb3ec5 DG	220	strncpy(attr->name, ev->name, LTTNG_KERNEL_SYM_NAME_LEN);
dbbb3ec5 DG	221	attr->name[LTTNG_KERNEL_SYM_NAME_LEN - 1] = '\0';
f3ed775e	222
54012638 DG	223	/* Setting up a kernel event */
	224	lke->fd = 0;
	225	lke->event = attr;
d36b8583	226	lke->enabled = 1;
e75cda3a	227	lke->ctx = NULL;
54012638 DG	228
	229	return lke;
	230
	231	error:
	232	return NULL;
	233	}
	234
	235	/*
050349bb	236	* Allocate and initialize a kernel metadata.
54012638	237	*
050349bb	238	* Return pointer to structure or NULL.
54012638	239	*/
62499ad6	240	struct ltt_kernel_metadata trace_kernel_create_metadata(char path)
54012638 DG	241	{
	242	int ret;
	243	struct ltt_kernel_metadata *lkm;
f3ed775e	244	struct lttng_channel *chan;
54012638	245
ba7f0ae5 DG	246	lkm = zmalloc(sizeof(struct ltt_kernel_metadata));
ba7f0ae5 DG	247	chan = zmalloc(sizeof(struct lttng_channel));
f3ed775e	248	if (lkm == NULL \|\| chan == NULL) {
ba7f0ae5	249	perror("kernel metadata zmalloc");
54012638 DG	250	goto error;
	251	}
	252
	253	/* Set default attributes */
f3ed775e	254	chan->attr.overwrite = DEFAULT_CHANNEL_OVERWRITE;
b389abbe MD	255	chan->attr.subbuf_size = DEFAULT_METADATA_SUBBUF_SIZE;
b389abbe MD	256	chan->attr.num_subbuf = DEFAULT_METADATA_SUBBUF_NUM;
f3ed775e DG	257	chan->attr.switch_timer_interval = DEFAULT_CHANNEL_SWITCH_TIMER;
f3ed775e DG	258	chan->attr.read_timer_interval = DEFAULT_CHANNEL_READ_TIMER;
7d452e12	259	chan->attr.output = DEFAULT_KERNEL_CHANNEL_OUTPUT;
54012638 DG	260
	261	/* Init metadata */
	262	lkm->fd = 0;
f3ed775e	263	lkm->conf = chan;
54012638	264	/* Set default metadata path */
58a97671	265	ret = asprintf(&lkm->pathname, "%s/metadata", path);
54012638 DG	266	if (ret < 0) {
	267	perror("asprintf kernel metadata");
	268	goto error;
	269	}
	270
	271	return lkm;
	272
	273	error:
	274	return NULL;
	275	}
	276
	277	/*
050349bb DG	278	* Allocate and initialize a kernel stream. The stream is set to ACTIVE_FD by
050349bb DG	279	* default.
54012638	280	*
050349bb	281	* Return pointer to structure or NULL.
54012638	282	*/
62499ad6	283	struct ltt_kernel_stream *trace_kernel_create_stream(void)
54012638 DG	284	{
	285	struct ltt_kernel_stream *lks;
	286
ba7f0ae5	287	lks = zmalloc(sizeof(struct ltt_kernel_stream));
54012638	288	if (lks == NULL) {
ba7f0ae5	289	perror("kernel stream zmalloc");
54012638 DG	290	goto error;
	291	}
	292
	293	/* Init stream */
	294	lks->fd = 0;
	295	lks->pathname = NULL;
	296	lks->state = 0;
	297
	298	return lks;
	299
	300	error:
	301	return NULL;
	302	}
c363b55d	303
050349bb DG	304	/*
	305	* Cleanup kernel stream structure.
	306	*/
62499ad6	307	void trace_kernel_destroy_stream(struct ltt_kernel_stream *stream)
c363b55d	308	{
33a2b854	309	DBG("[trace] Closing stream fd %d", stream->fd);
c363b55d DG	310	/* Close kernel fd */
c363b55d DG	311	close(stream->fd);
c363b55d DG	312	/* Remove from stream list */
c363b55d DG	313	cds_list_del(&stream->list);
f9815039 DG	314
f9815039 DG	315	free(stream->pathname);
c363b55d DG	316	free(stream);
	317	}
	318
050349bb DG	319	/*
	320	* Cleanup kernel event structure.
	321	*/
62499ad6	322	void trace_kernel_destroy_event(struct ltt_kernel_event *event)
c363b55d	323	{
87eb4ab8 MD	324	if (event->fd >= 0) {
	325	DBG("[trace] Closing event fd %d", event->fd);
	326	/* Close kernel fd */
	327	close(event->fd);
	328	} else {
	329	DBG("[trace] Tearing down event (no associated fd)");
	330	}
c363b55d DG	331
	332	/* Remove from event list */
	333	cds_list_del(&event->list);
f9815039 DG	334
	335	free(event->event);
	336	free(event->ctx);
c363b55d DG	337	free(event);
	338	}
	339
050349bb DG	340	/*
	341	* Cleanup kernel channel structure.
	342	*/
62499ad6	343	void trace_kernel_destroy_channel(struct ltt_kernel_channel *channel)
c363b55d	344	{
af9737e9 DG	345	struct ltt_kernel_stream stream, stmp;
af9737e9 DG	346	struct ltt_kernel_event event, etmp;
c363b55d	347
33a2b854	348	DBG("[trace] Closing channel fd %d", channel->fd);
c363b55d DG	349	/* Close kernel fd */
c363b55d DG	350	close(channel->fd);
c363b55d DG	351
c363b55d DG	352	/* For each stream in the channel list */
af9737e9	353	cds_list_for_each_entry_safe(stream, stmp, &channel->stream_list.head, list) {
62499ad6	354	trace_kernel_destroy_stream(stream);
c363b55d DG	355	}
	356
	357	/* For each event in the channel list */
af9737e9	358	cds_list_for_each_entry_safe(event, etmp, &channel->events_list.head, list) {
62499ad6	359	trace_kernel_destroy_event(event);
c363b55d DG	360	}
	361
	362	/* Remove from channel list */
	363	cds_list_del(&channel->list);
f9815039 DG	364
	365	free(channel->pathname);
	366	free(channel->channel);
	367	free(channel->ctx);
c363b55d DG	368	free(channel);
	369	}
	370
050349bb DG	371	/*
	372	* Cleanup kernel metadata structure.
	373	*/
62499ad6	374	void trace_kernel_destroy_metadata(struct ltt_kernel_metadata *metadata)
c363b55d	375	{
33a2b854	376	DBG("[trace] Closing metadata fd %d", metadata->fd);
c363b55d DG	377	/* Close kernel fd */
c363b55d DG	378	close(metadata->fd);
c363b55d	379
f9815039 DG	380	free(metadata->conf);
f9815039 DG	381	free(metadata->pathname);
c363b55d DG	382	free(metadata);
	383	}
	384
050349bb	385	/*
62499ad6	386	* Cleanup kernel session structure
050349bb	387	*/
62499ad6	388	void trace_kernel_destroy_session(struct ltt_kernel_session *session)
c363b55d	389	{
af9737e9	390	struct ltt_kernel_channel channel, ctmp;
c363b55d	391
33a2b854	392	DBG("[trace] Closing session fd %d", session->fd);
c363b55d DG	393	/* Close kernel fds */
c363b55d DG	394	close(session->fd);
f9815039	395
70dc1c34 DG	396	if (session->metadata_stream_fd != 0) {
	397	DBG("[trace] Closing metadata stream fd %d", session->metadata_stream_fd);
	398	close(session->metadata_stream_fd);
	399	}
c363b55d	400
d36b8583	401	if (session->metadata != NULL) {
62499ad6	402	trace_kernel_destroy_metadata(session->metadata);
d36b8583	403	}
c363b55d	404
af9737e9	405	cds_list_for_each_entry_safe(channel, ctmp, &session->channel_list.head, list) {
62499ad6	406	trace_kernel_destroy_channel(channel);
c363b55d DG	407	}
c363b55d DG	408
f9815039	409	free(session->trace_path);
c363b55d DG	410	free(session);
c363b55d DG	411	}