[lttng-tools.git] / ltt-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 <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;
	}

	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 = 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);

	/* 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 = 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);
	/* 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)
{
	DBG("[trace] Closing event fd %d", event->fd);
	/* Close kernel fd */
	close(event->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
	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
	6	* as published by the Free Software Foundation; only version 2
	7	* of the License.
	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>
	23	#include <unistd.h>
	24
	25	#include <lttngerr.h>
	26
	27	#include "trace-kernel.h"
	28
	29	/*
	30	* Find the channel name for the given kernel session.
	31	*/
	32	struct ltt_kernel_channel *trace_kernel_get_channel_by_name(
	33	char name, struct ltt_kernel_session session)
	34	{
	35	struct ltt_kernel_channel *chan;
	36
	37	if (session == NULL) {
	38	ERR("Undefine session");
	39	goto error;
	40	}
	41
	42	DBG("Trying to find channel %s", name);
	43
	44	cds_list_for_each_entry(chan, &session->channel_list.head, list) {
	45	if (strcmp(name, chan->channel->name) == 0) {
	46	DBG("Found channel by name %s", name);
	47	return chan;
	48	}
	49	}
	50
	51	error:
	52	return NULL;
	53	}
	54
	55	/*
	56	* Find the event name for the given channel.
	57	*/
	58	struct ltt_kernel_event *trace_kernel_get_event_by_name(
	59	char name, struct ltt_kernel_channel channel)
	60	{
	61	struct ltt_kernel_event *ev;
	62
	63	if (channel == NULL) {
	64	ERR("Undefine channel");
	65	goto error;
	66	}
	67
	68	cds_list_for_each_entry(ev, &channel->events_list.head, list) {
	69	if (strcmp(name, ev->event->name) == 0) {
	70	DBG("Found event by name %s for channel %s", name,
	71	channel->channel->name);
	72	return ev;
	73	}
	74	}
	75
	76	error:
	77	return NULL;
	78	}
	79
	80	/*
	81	* Allocate and initialize a kernel session data structure.
	82	*
	83	* Return pointer to structure or NULL.
	84	*/
	85	struct ltt_kernel_session trace_kernel_create_session(char path)
	86	{
	87	int ret;
	88	struct ltt_kernel_session *lks;
	89
	90	/* Allocate a new ltt kernel session */
	91	lks = malloc(sizeof(struct ltt_kernel_session));
	92	if (lks == NULL) {
	93	perror("create kernel session malloc");
	94	goto error;
	95	}
	96
	97	/* Init data structure */
	98	lks->fd = 0;
	99	lks->metadata_stream_fd = 0;
	100	lks->channel_count = 0;
	101	lks->stream_count_global = 0;
	102	lks->metadata = NULL;
	103	lks->consumer_fd = 0;
	104	CDS_INIT_LIST_HEAD(&lks->channel_list.head);
	105
	106	/* Set session path */
	107	ret = asprintf(&lks->trace_path, "%s/kernel", path);
	108	if (ret < 0) {
	109	perror("asprintf kernel traces path");
	110	goto error;
	111	}
	112
	113	return lks;
	114
	115	error:
	116	return NULL;
	117	}
	118
	119	/*
	120	* Allocate and initialize a kernel channel data structure.
	121	*
	122	* Return pointer to structure or NULL.
	123	*/
	124	struct ltt_kernel_channel trace_kernel_create_channel(struct lttng_channel chan, char *path)
	125	{
	126	int ret;
	127	struct ltt_kernel_channel *lkc;
	128
	129	lkc = malloc(sizeof(struct ltt_kernel_channel));
	130	if (lkc == NULL) {
	131	perror("ltt_kernel_channel malloc");
	132	goto error;
	133	}
	134
	135	lkc->channel = malloc(sizeof(struct lttng_channel));
	136	if (lkc->channel == NULL) {
	137	perror("lttng_channel malloc");
	138	goto error;
	139	}
	140	memcpy(lkc->channel, chan, sizeof(struct lttng_channel));
	141
	142	lkc->fd = 0;
	143	lkc->stream_count = 0;
	144	lkc->event_count = 0;
	145	lkc->enabled = 1;
	146	lkc->ctx = NULL;
	147	/* Init linked list */
	148	CDS_INIT_LIST_HEAD(&lkc->events_list.head);
	149	CDS_INIT_LIST_HEAD(&lkc->stream_list.head);
	150	/* Set default trace output path */
	151	ret = asprintf(&lkc->pathname, "%s", path);
	152	if (ret < 0) {
	153	perror("asprintf kernel create channel");
	154	goto error;
	155	}
	156
	157	return lkc;
	158
	159	error:
	160	return NULL;
	161	}
	162
	163	/*
	164	* Allocate and initialize a kernel event. Set name and event type.
	165	*
	166	* Return pointer to structure or NULL.
	167	*/
	168	struct ltt_kernel_event trace_kernel_create_event(struct lttng_event ev)
	169	{
	170	struct ltt_kernel_event *lke;
	171	struct lttng_kernel_event *attr;
	172
	173	lke = malloc(sizeof(struct ltt_kernel_event));
	174	attr = malloc(sizeof(struct lttng_kernel_event));
	175	if (lke == NULL \|\| attr == NULL) {
	176	perror("kernel event malloc");
	177	goto error;
	178	}
	179
	180	switch (ev->type) {
	181	case LTTNG_EVENT_PROBE:
	182	attr->instrumentation = LTTNG_KERNEL_KPROBE;
	183	attr->u.kprobe.addr = ev->attr.probe.addr;
	184	attr->u.kprobe.offset = ev->attr.probe.offset;
	185	strncpy(attr->u.kprobe.symbol_name,
	186	ev->attr.probe.symbol_name, LTTNG_SYM_NAME_LEN);
	187	attr->u.kprobe.symbol_name[LTTNG_SYM_NAME_LEN - 1] = '\0';
	188	break;
	189	case LTTNG_EVENT_FUNCTION:
	190	attr->instrumentation = LTTNG_KERNEL_KRETPROBE;
	191	attr->u.kretprobe.addr = ev->attr.probe.addr;
	192	attr->u.kretprobe.offset = ev->attr.probe.offset;
	193	attr->u.kretprobe.offset = ev->attr.probe.offset;
	194	strncpy(attr->u.kretprobe.symbol_name,
	195	ev->attr.probe.symbol_name, LTTNG_SYM_NAME_LEN);
	196	attr->u.kretprobe.symbol_name[LTTNG_SYM_NAME_LEN - 1] = '\0';
	197	break;
	198	case LTTNG_EVENT_FUNCTION_ENTRY:
	199	attr->instrumentation = LTTNG_KERNEL_FUNCTION;
	200	strncpy(attr->u.ftrace.symbol_name,
	201	ev->attr.ftrace.symbol_name, LTTNG_SYM_NAME_LEN);
	202	attr->u.ftrace.symbol_name[LTTNG_SYM_NAME_LEN - 1] = '\0';
	203	break;
	204	case LTTNG_EVENT_TRACEPOINT:
	205	attr->instrumentation = LTTNG_KERNEL_TRACEPOINT;
	206	break;
	207	default:
	208	ERR("Unknown kernel instrumentation type (%d)", ev->type);
	209	goto error;
	210	}
	211
	212	/* Copy event name */
	213	strncpy(attr->name, ev->name, LTTNG_SYM_NAME_LEN);
	214	attr->name[LTTNG_SYM_NAME_LEN - 1] = '\0';
	215
	216	/* Setting up a kernel event */
	217	lke->fd = 0;
	218	lke->event = attr;
	219	lke->enabled = 1;
	220	lke->ctx = NULL;
	221
	222	return lke;
	223
	224	error:
	225	return NULL;
	226	}
	227
	228	/*
	229	* Allocate and initialize a kernel metadata.
	230	*
	231	* Return pointer to structure or NULL.
	232	*/
	233	struct ltt_kernel_metadata trace_kernel_create_metadata(char path)
	234	{
	235	int ret;
	236	struct ltt_kernel_metadata *lkm;
	237	struct lttng_channel *chan;
	238
	239	lkm = malloc(sizeof(struct ltt_kernel_metadata));
	240	chan = malloc(sizeof(struct lttng_channel));
	241	if (lkm == NULL \|\| chan == NULL) {
	242	perror("kernel metadata malloc");
	243	goto error;
	244	}
	245
	246	/* Set default attributes */
	247	chan->attr.overwrite = DEFAULT_CHANNEL_OVERWRITE;
	248	chan->attr.subbuf_size = DEFAULT_METADATA_SUBBUF_SIZE;
	249	chan->attr.num_subbuf = DEFAULT_METADATA_SUBBUF_NUM;
	250	chan->attr.switch_timer_interval = DEFAULT_CHANNEL_SWITCH_TIMER;
	251	chan->attr.read_timer_interval = DEFAULT_CHANNEL_READ_TIMER;
	252	chan->attr.output = DEFAULT_KERNEL_CHANNEL_OUTPUT;
	253
	254	/* Init metadata */
	255	lkm->fd = 0;
	256	lkm->conf = chan;
	257	/* Set default metadata path */
	258	ret = asprintf(&lkm->pathname, "%s/metadata", path);
	259	if (ret < 0) {
	260	perror("asprintf kernel metadata");
	261	goto error;
	262	}
	263
	264	return lkm;
	265
	266	error:
	267	return NULL;
	268	}
	269
	270	/*
	271	* Allocate and initialize a kernel stream. The stream is set to ACTIVE_FD by
	272	* default.
	273	*
	274	* Return pointer to structure or NULL.
	275	*/
	276	struct ltt_kernel_stream *trace_kernel_create_stream(void)
	277	{
	278	struct ltt_kernel_stream *lks;
	279
	280	lks = malloc(sizeof(struct ltt_kernel_stream));
	281	if (lks == NULL) {
	282	perror("kernel stream malloc");
	283	goto error;
	284	}
	285
	286	/* Init stream */
	287	lks->fd = 0;
	288	lks->pathname = NULL;
	289	lks->state = 0;
	290
	291	return lks;
	292
	293	error:
	294	return NULL;
	295	}
	296
	297	/*
	298	* Cleanup kernel stream structure.
	299	*/
	300	void trace_kernel_destroy_stream(struct ltt_kernel_stream *stream)
	301	{
	302	DBG("[trace] Closing stream fd %d", stream->fd);
	303	/* Close kernel fd */
	304	close(stream->fd);
	305	/* Remove from stream list */
	306	cds_list_del(&stream->list);
	307
	308	free(stream->pathname);
	309	free(stream);
	310	}
	311
	312	/*
	313	* Cleanup kernel event structure.
	314	*/
	315	void trace_kernel_destroy_event(struct ltt_kernel_event *event)
	316	{
	317	DBG("[trace] Closing event fd %d", event->fd);
	318	/* Close kernel fd */
	319	close(event->fd);
	320
	321	/* Remove from event list */
	322	cds_list_del(&event->list);
	323
	324	free(event->event);
	325	free(event->ctx);
	326	free(event);
	327	}
	328
	329	/*
	330	* Cleanup kernel channel structure.
	331	*/
	332	void trace_kernel_destroy_channel(struct ltt_kernel_channel *channel)
	333	{
	334	struct ltt_kernel_stream stream, stmp;
	335	struct ltt_kernel_event event, etmp;
	336
	337	DBG("[trace] Closing channel fd %d", channel->fd);
	338	/* Close kernel fd */
	339	close(channel->fd);
	340
	341	/* For each stream in the channel list */
	342	cds_list_for_each_entry_safe(stream, stmp, &channel->stream_list.head, list) {
	343	trace_kernel_destroy_stream(stream);
	344	}
	345
	346	/* For each event in the channel list */
	347	cds_list_for_each_entry_safe(event, etmp, &channel->events_list.head, list) {
	348	trace_kernel_destroy_event(event);
	349	}
	350
	351	/* Remove from channel list */
	352	cds_list_del(&channel->list);
	353
	354	free(channel->pathname);
	355	free(channel->channel);
	356	free(channel->ctx);
	357	free(channel);
	358	}
	359
	360	/*
	361	* Cleanup kernel metadata structure.
	362	*/
	363	void trace_kernel_destroy_metadata(struct ltt_kernel_metadata *metadata)
	364	{
	365	DBG("[trace] Closing metadata fd %d", metadata->fd);
	366	/* Close kernel fd */
	367	close(metadata->fd);
	368
	369	free(metadata->conf);
	370	free(metadata->pathname);
	371	free(metadata);
	372	}
	373
	374	/*
	375	* Cleanup kernel session structure
	376	*/
	377	void trace_kernel_destroy_session(struct ltt_kernel_session *session)
	378	{
	379	struct ltt_kernel_channel channel, ctmp;
	380
	381	DBG("[trace] Closing session fd %d", session->fd);
	382	/* Close kernel fds */
	383	close(session->fd);
	384
	385	if (session->metadata_stream_fd != 0) {
	386	DBG("[trace] Closing metadata stream fd %d", session->metadata_stream_fd);
	387	close(session->metadata_stream_fd);
	388	}
	389
	390	if (session->metadata != NULL) {
	391	trace_kernel_destroy_metadata(session->metadata);
	392	}
	393
	394	cds_list_for_each_entry_safe(channel, ctmp, &session->channel_list.head, list) {
	395	trace_kernel_destroy_channel(channel);
	396	}
	397
	398	free(session->trace_path);
	399	free(session);
	400	}