[lttng-tools.git] / ltt-sessiond / trace-ust.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 <lttng-share.h>

#include "trace-ust.h"

/*
 * Return an UST session by traceable app PID.
 */
struct ltt_ust_session *trace_ust_get_session_by_pid(pid_t pid,
		struct ltt_ust_session_list *session_list)
{
	struct ltt_ust_session *lus;

	cds_list_for_each_entry(lus, &session_list->head, list) {
		if (lus->app->pid == pid) {
			DBG("Found UST session by pid %d", pid);
			return lus;
		}
	}

	return NULL;
}

/*
 * Find the channel name for the given ust session.
 */
struct ltt_ust_channel *trace_ust_get_channel_by_name(
		char *name, struct ltt_ust_session *session)
{
	struct ltt_ust_channel *chan;

	if (session == NULL) {
		ERR("Undefine session");
		goto error;
	}

	cds_list_for_each_entry(chan, &session->channels.head, list) {
		if (strcmp(name, chan->name) == 0) {
			DBG("Found UST channel by name %s", name);
			return chan;
		}
	}

error:
	return NULL;
}

/*
 * Find the event name for the given channel.
 */
struct ltt_ust_event *trace_ust_get_event_by_name(
		char *name, struct ltt_ust_channel *channel)
{
	struct ltt_ust_event *ev;

	if (channel == NULL) {
		ERR("Undefine channel");
		goto error;
	}

	cds_list_for_each_entry(ev, &channel->events.head, list) {
		if (strcmp(name, ev->event->name) == 0) {
			DBG("Found UST event by name %s for channel %s", name,
					channel->name);
			return ev;
		}
	}

error:
	return NULL;
}

/*
 * Allocate and initialize a ust session data structure.
 *
 * Return pointer to structure or NULL.
 */
struct ltt_ust_session *trace_ust_create_session(char *path, pid_t pid)
{
	int ret;
	struct ltt_ust_session *lus;

	/* Allocate a new ltt ust session */
	lus = malloc(sizeof(struct ltt_ust_session));
	if (lus == NULL) {
		perror("create ust session malloc");
		goto error;
	}

	/* Init data structure */
	lus->handle = -1;
	lus->enabled = 1;
	lus->uconsumer_fds_sent = 0;
	lus->path = NULL;
	lus->metadata = NULL;
	lus->app = NULL;	/* TODO: Search app by PID */
	lus->channels.count = 0;
	CDS_INIT_LIST_HEAD(&lus->channels.head);

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

	return lus;

error:
	return NULL;
}

/*
 * Allocate and initialize a ust channel data structure.
 *
 * Return pointer to structure or NULL.
 */
struct ltt_ust_channel *trace_ust_create_channel(char *name, char *path,
		struct lttng_ust_channel *chan)
{
	int ret;
	struct ltt_ust_channel *luc;

	luc = malloc(sizeof(struct ltt_ust_channel));
	if (luc == NULL) {
		perror("ltt_ust_channel malloc");
		goto error;
	}

	luc->attr = malloc(sizeof(struct lttng_ust_channel));
	if (luc->attr == NULL) {
		perror("lttng_ust_channel malloc");
		goto error;
	}
	memcpy(luc->attr, chan, sizeof(struct lttng_ust_channel));

	luc->handle = -1;
	luc->enabled = 1;
	luc->ctx = NULL;
	luc->events.count = 0;
	CDS_INIT_LIST_HEAD(&luc->events.head);

	/* Copy channel name */
	strncpy(luc->name, name, LTTNG_UST_SYM_NAME_LEN);
	luc->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';

	/* Set trace output path */
	ret = asprintf(&luc->trace_path, "%s", path);
	if (ret < 0) {
		perror("asprintf ust create channel");
		goto error;
	}

	return luc;

error:
	return NULL;
}

/*
 * Allocate and initialize a ust event. Set name and event type.
 *
 * Return pointer to structure or NULL.
 */
struct ltt_ust_event *trace_ust_create_event(struct lttng_event *ev)
{
	struct ltt_ust_event *lue;
	struct lttng_ust_event *event;

	lue = malloc(sizeof(struct ltt_ust_event));
	event = malloc(sizeof(struct lttng_ust_event));
	if (lue == NULL || event == NULL) {
		perror("ust event malloc");
		goto error;
	}

	switch (ev->type) {
	case LTTNG_EVENT_PROBE:
		event->instrumentation = LTTNG_UST_PROBE;
		break;
	case LTTNG_EVENT_FUNCTION:
		event->instrumentation = LTTNG_UST_FUNCTION;
		break;
	case LTTNG_EVENT_FUNCTION_ENTRY:
		event->instrumentation = LTTNG_UST_FUNCTION;
		break;
	case LTTNG_EVENT_TRACEPOINT:
		event->instrumentation = LTTNG_UST_TRACEPOINT;
		break;
	default:
		ERR("Unknown ust instrumentation type (%d)", ev->type);
		goto error;
	}

	/* Copy event name */
	strncpy(event->name, ev->name, LTTNG_UST_SYM_NAME_LEN);
	event->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';

	/* Setting up a ust event */
	lue->handle = -1;
	lue->event = event;
	lue->enabled = 1;
	lue->ctx = NULL;

	return lue;

error:
	return NULL;
}

/*
 * Allocate and initialize a ust metadata.
 *
 * Return pointer to structure or NULL.
 */
struct ltt_ust_metadata *trace_ust_create_metadata(char *path)
{
	int ret;
	struct ltt_ust_metadata *lum;
	struct lttng_ust_channel *attr;

	lum = malloc(sizeof(struct ltt_ust_metadata));
	attr = malloc(sizeof(struct lttng_ust_channel));
	if (lum == NULL || attr == NULL) {
		perror("ust metadata malloc");
		goto error;
	}

	/* Set default attributes */
	attr->overwrite = DEFAULT_CHANNEL_OVERWRITE;
	attr->subbuf_size = DEFAULT_METADATA_SUBBUF_SIZE;
	attr->num_subbuf = DEFAULT_METADATA_SUBBUF_NUM;
	attr->switch_timer_interval = DEFAULT_CHANNEL_SWITCH_TIMER;
	attr->read_timer_interval = DEFAULT_CHANNEL_READ_TIMER;
	attr->output = DEFAULT_UST_CHANNEL_OUTPUT;

	lum->attr = attr;
	lum->handle = -1;
	/* Set metadata trace path */
	ret = asprintf(&lum->trace_path, "%s/metadata", path);
	if (ret < 0) {
		perror("asprintf ust metadata");
		goto error;
	}

	return lum;

error:
	return NULL;
}

/*
 * Cleanup ust event structure.
 */
void trace_ust_destroy_event(struct ltt_ust_event *event)
{
	DBG("[trace] Destroy ust event %s", event->event->name);

	/* Free attributes */
	free(event->event);
	free(event->ctx);

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

/*
 * Cleanup ust channel structure.
 */
void trace_ust_destroy_channel(struct ltt_ust_channel *channel)
{
	struct ltt_ust_event *event, *etmp;

	DBG("[trace] Destroy ust channel %d", channel->handle);

	free(channel->trace_path);
	/* Free attributes structure */
	free(channel->attr);
	free(channel->ctx);

	/* For each event in the channel list */
	cds_list_for_each_entry_safe(event, etmp, &channel->events.head, list) {
		trace_ust_destroy_event(event);
	}

	/* Remove from channel list */
	cds_list_del(&channel->list);
	free(channel);
}

/*
 * Cleanup ust metadata structure.
 */
void trace_ust_destroy_metadata(struct ltt_ust_metadata *metadata)
{
	DBG("[trace] Destroy ust metadata %d", metadata->handle);

	/* Free attributes */
	free(metadata->attr);
	free(metadata->trace_path);

	free(metadata);
}

/*
 * Cleanup ust session structure
 */
void trace_ust_destroy_session(struct ltt_ust_session *session)
{
	struct ltt_ust_channel *channel, *ctmp;

	DBG("[trace] Destroy ust session %d", session->handle);

	/* Extra safety */
	if (session == NULL) {
		return;
	}

	if (session->metadata != NULL) {
		trace_ust_destroy_metadata(session->metadata);
	}

	cds_list_for_each_entry_safe(channel, ctmp, &session->channels.head, list) {
		trace_ust_destroy_channel(channel);
	}

	free(session->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 modify it
	5	* under the terms of the GNU General Public License as published by the Free
	6	* Software Foundation; only version 2 of the License.
	7	*
	8	* This program is distributed in the hope that it will be useful, but WITHOUT
	9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	10	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	11	* more details.
	12	*
	13	* You should have received a copy of the GNU General Public License along with
	14	* this program; if not, write to the Free Software Foundation, Inc., 59 Temple
	15	* Place - Suite 330, Boston, MA 02111-1307, USA.
	16	*/
	17
	18	#define _GNU_SOURCE
	19	#include <stdio.h>
	20	#include <stdlib.h>
	21	#include <string.h>
	22	#include <unistd.h>
	23
	24	#include <lttngerr.h>
	25	#include <lttng-share.h>
	26
	27	#include "trace-ust.h"
	28
	29	/*
	30	* Return an UST session by traceable app PID.
	31	*/
	32	struct ltt_ust_session *trace_ust_get_session_by_pid(pid_t pid,
	33	struct ltt_ust_session_list *session_list)
	34	{
	35	struct ltt_ust_session *lus;
	36
	37	cds_list_for_each_entry(lus, &session_list->head, list) {
	38	if (lus->app->pid == pid) {
	39	DBG("Found UST session by pid %d", pid);
	40	return lus;
	41	}
	42	}
	43
	44	return NULL;
	45	}
	46
	47	/*
	48	* Find the channel name for the given ust session.
	49	*/
	50	struct ltt_ust_channel *trace_ust_get_channel_by_name(
	51	char name, struct ltt_ust_session session)
	52	{
	53	struct ltt_ust_channel *chan;
	54
	55	if (session == NULL) {
	56	ERR("Undefine session");
	57	goto error;
	58	}
	59
	60	cds_list_for_each_entry(chan, &session->channels.head, list) {
	61	if (strcmp(name, chan->name) == 0) {
	62	DBG("Found UST channel by name %s", name);
	63	return chan;
	64	}
	65	}
	66
	67	error:
	68	return NULL;
	69	}
	70
	71	/*
	72	* Find the event name for the given channel.
	73	*/
	74	struct ltt_ust_event *trace_ust_get_event_by_name(
	75	char name, struct ltt_ust_channel channel)
	76	{
	77	struct ltt_ust_event *ev;
	78
	79	if (channel == NULL) {
	80	ERR("Undefine channel");
	81	goto error;
	82	}
	83
	84	cds_list_for_each_entry(ev, &channel->events.head, list) {
	85	if (strcmp(name, ev->event->name) == 0) {
	86	DBG("Found UST event by name %s for channel %s", name,
	87	channel->name);
	88	return ev;
	89	}
	90	}
	91
	92	error:
	93	return NULL;
	94	}
	95
	96	/*
	97	* Allocate and initialize a ust session data structure.
	98	*
	99	* Return pointer to structure or NULL.
	100	*/
	101	struct ltt_ust_session trace_ust_create_session(char path, pid_t pid)
	102	{
	103	int ret;
	104	struct ltt_ust_session *lus;
	105
	106	/* Allocate a new ltt ust session */
	107	lus = malloc(sizeof(struct ltt_ust_session));
	108	if (lus == NULL) {
	109	perror("create ust session malloc");
	110	goto error;
	111	}
	112
	113	/* Init data structure */
	114	lus->handle = -1;
	115	lus->enabled = 1;
	116	lus->uconsumer_fds_sent = 0;
	117	lus->path = NULL;
	118	lus->metadata = NULL;
	119	lus->app = NULL; /* TODO: Search app by PID */
	120	lus->channels.count = 0;
	121	CDS_INIT_LIST_HEAD(&lus->channels.head);
	122
	123	/* Set session path */
	124	ret = asprintf(&lus->path, "%s/ust_%d", path, pid);
	125	if (ret < 0) {
	126	perror("asprintf kernel traces path");
	127	goto error;
	128	}
	129
	130	return lus;
	131
	132	error:
	133	return NULL;
	134	}
	135
	136	/*
	137	* Allocate and initialize a ust channel data structure.
	138	*
	139	* Return pointer to structure or NULL.
	140	*/
	141	struct ltt_ust_channel trace_ust_create_channel(char name, char *path,
	142	struct lttng_ust_channel *chan)
	143	{
	144	int ret;
	145	struct ltt_ust_channel *luc;
	146
	147	luc = malloc(sizeof(struct ltt_ust_channel));
	148	if (luc == NULL) {
	149	perror("ltt_ust_channel malloc");
	150	goto error;
	151	}
	152
	153	luc->attr = malloc(sizeof(struct lttng_ust_channel));
	154	if (luc->attr == NULL) {
	155	perror("lttng_ust_channel malloc");
	156	goto error;
	157	}
	158	memcpy(luc->attr, chan, sizeof(struct lttng_ust_channel));
	159
	160	luc->handle = -1;
	161	luc->enabled = 1;
	162	luc->ctx = NULL;
	163	luc->events.count = 0;
	164	CDS_INIT_LIST_HEAD(&luc->events.head);
	165
	166	/* Copy channel name */
	167	strncpy(luc->name, name, LTTNG_UST_SYM_NAME_LEN);
	168	luc->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
	169
	170	/* Set trace output path */
	171	ret = asprintf(&luc->trace_path, "%s", path);
	172	if (ret < 0) {
	173	perror("asprintf ust create channel");
	174	goto error;
	175	}
	176
	177	return luc;
	178
	179	error:
	180	return NULL;
	181	}
	182
	183	/*
	184	* Allocate and initialize a ust event. Set name and event type.
	185	*
	186	* Return pointer to structure or NULL.
	187	*/
	188	struct ltt_ust_event trace_ust_create_event(struct lttng_event ev)
	189	{
	190	struct ltt_ust_event *lue;
	191	struct lttng_ust_event *event;
	192
	193	lue = malloc(sizeof(struct ltt_ust_event));
	194	event = malloc(sizeof(struct lttng_ust_event));
	195	if (lue == NULL \|\| event == NULL) {
	196	perror("ust event malloc");
	197	goto error;
	198	}
	199
	200	switch (ev->type) {
	201	case LTTNG_EVENT_PROBE:
	202	event->instrumentation = LTTNG_UST_PROBE;
	203	break;
	204	case LTTNG_EVENT_FUNCTION:
	205	event->instrumentation = LTTNG_UST_FUNCTION;
	206	break;
	207	case LTTNG_EVENT_FUNCTION_ENTRY:
	208	event->instrumentation = LTTNG_UST_FUNCTION;
	209	break;
	210	case LTTNG_EVENT_TRACEPOINT:
	211	event->instrumentation = LTTNG_UST_TRACEPOINT;
	212	break;
	213	default:
	214	ERR("Unknown ust instrumentation type (%d)", ev->type);
	215	goto error;
	216	}
	217
	218	/* Copy event name */
	219	strncpy(event->name, ev->name, LTTNG_UST_SYM_NAME_LEN);
	220	event->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
	221
	222	/* Setting up a ust event */
	223	lue->handle = -1;
	224	lue->event = event;
	225	lue->enabled = 1;
	226	lue->ctx = NULL;
	227
	228	return lue;
	229
	230	error:
	231	return NULL;
	232	}
	233
	234	/*
	235	* Allocate and initialize a ust metadata.
	236	*
	237	* Return pointer to structure or NULL.
	238	*/
	239	struct ltt_ust_metadata trace_ust_create_metadata(char path)
	240	{
	241	int ret;
	242	struct ltt_ust_metadata *lum;
	243	struct lttng_ust_channel *attr;
	244
	245	lum = malloc(sizeof(struct ltt_ust_metadata));
	246	attr = malloc(sizeof(struct lttng_ust_channel));
	247	if (lum == NULL \|\| attr == NULL) {
	248	perror("ust metadata malloc");
	249	goto error;
	250	}
	251
	252	/* Set default attributes */
	253	attr->overwrite = DEFAULT_CHANNEL_OVERWRITE;
	254	attr->subbuf_size = DEFAULT_METADATA_SUBBUF_SIZE;
	255	attr->num_subbuf = DEFAULT_METADATA_SUBBUF_NUM;
	256	attr->switch_timer_interval = DEFAULT_CHANNEL_SWITCH_TIMER;
	257	attr->read_timer_interval = DEFAULT_CHANNEL_READ_TIMER;
	258	attr->output = DEFAULT_UST_CHANNEL_OUTPUT;
	259
	260	lum->attr = attr;
	261	lum->handle = -1;
	262	/* Set metadata trace path */
	263	ret = asprintf(&lum->trace_path, "%s/metadata", path);
	264	if (ret < 0) {
	265	perror("asprintf ust metadata");
	266	goto error;
	267	}
	268
	269	return lum;
	270
	271	error:
	272	return NULL;
	273	}
	274
	275	/*
	276	* Cleanup ust event structure.
	277	*/
	278	void trace_ust_destroy_event(struct ltt_ust_event *event)
	279	{
	280	DBG("[trace] Destroy ust event %s", event->event->name);
	281
	282	/* Free attributes */
	283	free(event->event);
	284	free(event->ctx);
	285
	286	/* Remove from event list */
	287	cds_list_del(&event->list);
	288	free(event);
	289	}
	290
	291	/*
	292	* Cleanup ust channel structure.
	293	*/
	294	void trace_ust_destroy_channel(struct ltt_ust_channel *channel)
	295	{
	296	struct ltt_ust_event event, etmp;
	297
	298	DBG("[trace] Destroy ust channel %d", channel->handle);
	299
	300	free(channel->trace_path);
	301	/* Free attributes structure */
	302	free(channel->attr);
	303	free(channel->ctx);
	304
	305	/* For each event in the channel list */
	306	cds_list_for_each_entry_safe(event, etmp, &channel->events.head, list) {
	307	trace_ust_destroy_event(event);
	308	}
	309
	310	/* Remove from channel list */
	311	cds_list_del(&channel->list);
	312	free(channel);
	313	}
	314
	315	/*
	316	* Cleanup ust metadata structure.
	317	*/
	318	void trace_ust_destroy_metadata(struct ltt_ust_metadata *metadata)
	319	{
	320	DBG("[trace] Destroy ust metadata %d", metadata->handle);
	321
	322	/* Free attributes */
	323	free(metadata->attr);
	324	free(metadata->trace_path);
	325
	326	free(metadata);
	327	}
	328
	329	/*
	330	* Cleanup ust session structure
	331	*/
	332	void trace_ust_destroy_session(struct ltt_ust_session *session)
	333	{
	334	struct ltt_ust_channel channel, ctmp;
	335
	336	DBG("[trace] Destroy ust session %d", session->handle);
	337
	338	/* Extra safety */
	339	if (session == NULL) {
	340	return;
	341	}
	342
	343	if (session->metadata != NULL) {
	344	trace_ust_destroy_metadata(session->metadata);
	345	}
	346
	347	cds_list_for_each_entry_safe(channel, ctmp, &session->channels.head, list) {
	348	trace_ust_destroy_channel(channel);
	349	}
	350
	351	free(session->path);
	352	free(session);
	353	}