[lttngtop.git] / src / lttng-session.c

#define _GNU_SOURCE         /* See feature_test_macros(7) */
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

#define event_list "lttng_statedump_start,lttng_statedump_end," \
	"lttng_statedump_process_state,lttng_statedump_file_descriptor," \
	"lttng_statedump_vm_map,lttng_statedump_network_interface," \
	"lttng_statedump_interrupt,sched_process_free," \
	"sched_switch,sched_process_fork"
#define context_list "-t pid -t procname -t tid -t ppid "

static
int check_or_start_sessiond()
{
	int ret;
	int sudo = 0;

	ret = system("pgrep -u root lttng-sessiond >/dev/null");
	if (ret == 0)
		goto end;

	if (getuid() != 0) {
		fprintf(stderr, "Trying to start lttng-sessiond with sudo\n");
		ret = system("sudo -l lttng-sessiond >/dev/null");
		if (ret < 0) {
			fprintf(stderr, "[error] You are not root and not "
					"allowed by sudo to start lttng-sessiond\n");
			ret = -1;
			goto end;
		}
		ret = system("sudo -l lttng >/dev/null");
		if (ret < 0) {
			fprintf(stderr, "[error] You are not root and not "
					"allowed by sudo to use lttng\n");
			ret = -1;
			goto end;
		}
		sudo = 1;
	}

	if (sudo)
		ret = system("sudo lttng-sessiond -d");
	else
		ret = system("lttng-sessiond -d");

	if (ret != 0) {
		fprintf(stderr, "Error starting lttng-sessiond as root\n");
		ret = -1;
		goto end;
	}

end:
	return ret;
}

static
int check_or_start_relayd()
{
	int ret;

	ret = system("pgrep lttng-relayd >/dev/null");
	if (ret == 0)
		goto end;

	ret = system("lttng-relayd -d");
	if (ret != 0) {
		fprintf(stderr, "Error starting lttng-relayd\n");
		ret = -1;
		goto end;
	}

end:
	return ret;
}

/*
 * Return 0 if in tracing group or root, 1 if sudo is needed (and working),
 * a negative value on error.
 */
static
int check_tracing_group()
{
	int ret;

	ret = getuid();
	if (ret == 0)
		goto end;

	ret = system("groups|grep tracing >/dev/null");
	if (ret == 0) {
		goto end;
	}

	ret = system("sudo lttng --version >/dev/null");
	if (ret != 0) {
		fprintf(stderr, "Error executing lttng with sudo, you need to "
				"be root or in the \"tracing\" group to start "
				"kernel tracing\n");
		ret = -1;
		goto end;
	} else {
		ret = 1;
	}

end:
	return ret;
}

static
int check_lttng_modules(int sudo)
{
	int ret;

	if (sudo) {
		ret = system("sudo lttng list -k | grep sched_switch >/dev/null");
	} else {
		ret = system("lttng list -k | grep sched_switch >/dev/null");
	}
	if (ret != 0) {
		fprintf(stderr, "Error listing kernel events, "
				"lttng-modules might not be installed\n");
		goto end;
	}

end:
	return ret;
}

static
int check_requirements(int *sudo)
{
	int ret;

	ret = check_or_start_sessiond();
	if (ret < 0)
		goto end;
	ret = check_or_start_relayd();
	if (ret < 0)
		goto end;
	ret = check_tracing_group();
	if (ret < 0)
		goto end;
	else if (ret == 1)
		*sudo = 1;

	ret = check_lttng_modules(*sudo);
	if (ret < 0)
		goto end;
end:
	return ret;
}

/*
 * Allocate a random string, must be freed by the caller.
 */
static
char *random_session_name()
{
	uint64_t id;
	char *str = NULL;
	int ret;

	FILE *f = fopen( "/dev/urandom", "r");
	if (!f) {
		perror("fopen");
		goto end;
	}

	ret = fread(&id, 1, sizeof(uint64_t), f);
	if (ret < sizeof(id)) {
		perror("fread");
		goto end;
	}

	ret = asprintf(&str, "lttngtop-%" PRIu64, id);
	if (ret < 0) {
		fprintf(stderr, "Error allocating session name");
		str = NULL;
		goto end;
	}

	ret = fclose(f);
	if (ret != 0) {
		perror("fclose");
		goto end;
	}

end:
	return str;
}

static
int check_session_name(char *name, int sudo)
{
	int ret;
	char cmd[1024];

	ret = sprintf(cmd, "%s lttng list | grep %s >/dev/null",
			(sudo) ? "sudo" : " ", name);
	if (ret < 0) {
		fprintf(stderr, "Allocating cmd\n");
		goto end;
	}

	ret = (system(cmd));
	if (ret == 0) {
		fprintf(stderr, "Error: session %s already exist, either we "
				"are not random enough or something is "
				"really wrong\n", name);
		ret = -1;
		goto end;
	}

end:
	return ret;
}

static
int local_session(char *name, int sudo)
{
	int ret;
	char cmd[1024];

	ret = sprintf(cmd, "%s lttng create %s >/dev/null",
			(sudo) ? "sudo" : " ", name);
	if (ret < 0) {
		fprintf(stderr, "Allocating cmd\n");
		goto end;
	}
	ret = (system(cmd));
	if (ret != 0) {
		fprintf(stderr, "Error: creating the session\n");
		ret = -1;
		goto end;
	}

end:
	return ret;
}

static
int live_local_session(char *name, int sudo)
{
	int ret;
	char cmd[1024];

	ret = sprintf(cmd, "%s lttng create %s --live 1000000 -U net://localhost >/dev/null",
			(sudo) ? "sudo" : " ", name);
	if (ret < 0) {
		fprintf(stderr, "Allocating cmd\n");
		goto end;
	}
	ret = (system(cmd));
	if (ret != 0) {
		fprintf(stderr, "Error: creating the session\n");
		ret = -1;
		goto end;
	}

end:
	return ret;
}

static
int enable_events(char *name, int sudo)
{
	int ret;
	char cmd[1024];

	ret = sprintf(cmd, "%s lttng enable-event -s %s -k %s >/dev/null",
			(sudo) ? "sudo" : " ", name, event_list);
	if (ret < 0) {
		fprintf(stderr, "Allocating cmd\n");
		goto end;
	}

	ret = (system(cmd));
	if (ret != 0) {
		fprintf(stderr, "Error: enabling events\n");
		ret = -1;
		goto end;
	}

end:
	return ret;
}

static
int add_contexts(char *name, int sudo)
{
	int ret;
	char cmd[1024];

	ret = sprintf(cmd, "%s lttng add-context -s %s -k %s >/dev/null",
			(sudo) ? "sudo" : " ", name, context_list);
	if (ret < 0) {
		fprintf(stderr, "allocating cmd\n");
		goto end;
	}

	ret = (system(cmd));
	if (ret != 0) {
		fprintf(stderr, "error: adding contexts\n");
		ret = -1;
		goto end;
	}

end:
	return ret;
}

static
int start(char *name, int sudo, int local)
{
	int ret;
	char cmd[1024];

	ret = sprintf(cmd, "%s lttng start %s >/dev/null",
			(sudo) ? "sudo" : " ", name);
	if (ret < 0) {
		fprintf(stderr, "allocating cmd\n");
		goto end;
	}

	ret = (system(cmd));
	if (ret != 0) {
		fprintf(stderr, "error: starting the session %s\n", name);
		ret = -1;
		goto end;
	}

	if (local) {
		ret = sprintf(cmd, "%s lttng list|grep %s|cut -d'(' -f2|cut -d ')' -f1",
				(sudo) ? "sudo" : " ", name);
	} else {
		ret = sprintf(cmd, "lttngtop -r net://localhost|grep %s|cut -d' ' -f1",
				name);
	}
	if (ret < 0) {
		fprintf(stderr, "allocating cmd\n");
		goto end;
	}
	fprintf(stderr, "%s session started : ",
			(local) ? "Local" : "Live");
	ret = (system(cmd));
	if (ret != 0) {
		fprintf(stderr, "error: listing the sessions\n");
		ret = -1;
		goto end;
	}

end:
	return ret;
}

static
int destroy(char *name)
{
	int ret;
	int sudo = 0;
	char cmd[1024];

	if (getuid() != 0) {
		ret = system("sudo -l lttng >/dev/null");
		if (ret < 0) {
			fprintf(stderr, "[error] You are not root and not "
					"allowed by sudo to use lttng\n");
			ret = -1;
			goto end;
		}
		sudo = 1;
	}

	ret = sprintf(cmd, "%s lttng destroy %s >/dev/null",
			(sudo) ? "sudo" : " ", name);
	if (ret < 0) {
		fprintf(stderr, "allocating cmd\n");
		goto end;
	}

	ret = (system(cmd));
	if (ret != 0) {
		fprintf(stderr, "error: destroying the session %s\n", name);
		ret = -1;
		goto end;
	}

end:
	return ret;
}

int create_local_session()
{
	int ret;
	char *name;
	int sudo = 0;

	ret = check_requirements(&sudo);

	name = random_session_name();
	if (!name) {
		ret = -1;
		goto end;
	}

	ret = check_session_name(name, sudo);
	if (ret < 0) {
		goto end_free;
	}

	ret = local_session(name, sudo);
	if (ret < 0) {
		goto end_free;
	}

	ret = enable_events(name, sudo);
	if (ret < 0) {
		goto end_free;
	}

	ret = add_contexts(name, sudo);
	if (ret < 0) {
		goto end_free;
	}

	ret = start(name, sudo, 1);
	if (ret < 0) {
		goto end_free;
	}

end_free:
	free(name);
end:
	return ret;
}

int destroy_session(char *name)
{
	return destroy(name);
}

int create_live_local_session()
{
	int ret;
	char *name;
	int sudo = 0;

	ret = check_requirements(&sudo);

	name = random_session_name();
	if (!name) {
		ret = -1;
		goto end;
	}

	ret = check_session_name(name, sudo);
	if (ret < 0) {
		goto end_free;
	}

	ret = live_local_session(name, sudo);
	if (ret < 0) {
		goto end_free;
	}

	ret = enable_events(name, sudo);
	if (ret < 0) {
		goto end_free;
	}

	ret = add_contexts(name, sudo);
	if (ret < 0) {
		goto end_free;
	}

	ret = start(name, sudo, 0);
	if (ret < 0) {
		goto end_free;
	}

end_free:
	free(name);
end:
	return ret;
}

/*
int create_live_local_session();
int destroy_live_local_session();
*/
Commit	Line	Data
f248b7d8 JD	1	#define _GNU_SOURCE /* See feature_test_macros(7) */
	2	#include <stdlib.h>
	3	#include <unistd.h>
	4	#include <sys/types.h>
	5	#include <stdio.h>
	6	#include <stdint.h>
	7	#include <inttypes.h>
	8
	9	#define event_list "lttng_statedump_start,lttng_statedump_end," \
	10	"lttng_statedump_process_state,lttng_statedump_file_descriptor," \
	11	"lttng_statedump_vm_map,lttng_statedump_network_interface," \
	12	"lttng_statedump_interrupt,sched_process_free," \
	13	"sched_switch,sched_process_fork"
	14	#define context_list "-t pid -t procname -t tid -t ppid "
	15
	16	static
	17	int check_or_start_sessiond()
	18	{
	19	int ret;
	20	int sudo = 0;
	21
	22	ret = system("pgrep -u root lttng-sessiond >/dev/null");
	23	if (ret == 0)
	24	goto end;
	25
	26	if (getuid() != 0) {
	27	fprintf(stderr, "Trying to start lttng-sessiond with sudo\n");
	28	ret = system("sudo -l lttng-sessiond >/dev/null");
	29	if (ret < 0) {
	30	fprintf(stderr, "[error] You are not root and not "
	31	"allowed by sudo to start lttng-sessiond\n");
	32	ret = -1;
	33	goto end;
	34	}
26d63ddf JD	35	ret = system("sudo -l lttng >/dev/null");
	36	if (ret < 0) {
	37	fprintf(stderr, "[error] You are not root and not "
	38	"allowed by sudo to use lttng\n");
	39	ret = -1;
	40	goto end;
	41	}
f248b7d8 JD	42	sudo = 1;
	43	}
	44
	45	if (sudo)
	46	ret = system("sudo lttng-sessiond -d");
	47	else
	48	ret = system("lttng-sessiond -d");
	49
	50	if (ret != 0) {
	51	fprintf(stderr, "Error starting lttng-sessiond as root\n");
	52	ret = -1;
	53	goto end;
	54	}
	55
	56	end:
	57	return ret;
	58	}
	59
	60	static
	61	int check_or_start_relayd()
	62	{
	63	int ret;
	64
	65	ret = system("pgrep lttng-relayd >/dev/null");
	66	if (ret == 0)
	67	goto end;
	68
	69	ret = system("lttng-relayd -d");
	70	if (ret != 0) {
	71	fprintf(stderr, "Error starting lttng-relayd\n");
	72	ret = -1;
	73	goto end;
	74	}
	75
	76	end:
	77	return ret;
	78	}
	79
	80	/*
	81	* Return 0 if in tracing group or root, 1 if sudo is needed (and working),
	82	* a negative value on error.
	83	*/
	84	static
	85	int check_tracing_group()
	86	{
	87	int ret;
	88
	89	ret = getuid();
	90	if (ret == 0)
	91	goto end;
	92
	93	ret = system("groups\|grep tracing >/dev/null");
	94	if (ret == 0) {
	95	goto end;
	96	}
	97
	98	ret = system("sudo lttng --version >/dev/null");
	99	if (ret != 0) {
	100	fprintf(stderr, "Error executing lttng with sudo, you need to "
	101	"be root or in the \"tracing\" group to start "
	102	"kernel tracing\n");
	103	ret = -1;
	104	goto end;
	105	} else {
106	ret = 1;
107	}
108
109	end:
110	return ret;
111	}
112
113	static
114	int check_lttng_modules(int sudo)
115	{
116	int ret;
117
118	if (sudo) {
119	ret = system("sudo lttng list -k \| grep sched_switch >/dev/null");
120	} else {
121	ret = system("lttng list -k \| grep sched_switch >/dev/null");
122	}
123	if (ret != 0) {
124	fprintf(stderr, "Error listing kernel events, "
125	"lttng-modules might not be installed\n");
126	goto end;
127	}
128
129	end:
130	return ret;
131	}
132
133	static
134	int check_requirements(int *sudo)
135	{
136	int ret;
137
138	ret = check_or_start_sessiond();
139	if (ret < 0)
140	goto end;
141	ret = check_or_start_relayd();
142	if (ret < 0)
143	goto end;
144	ret = check_tracing_group();
145	if (ret < 0)
146	goto end;
147	else if (ret == 1)
148	*sudo = 1;
149
150	ret = check_lttng_modules(*sudo);
151	if (ret < 0)
152	goto end;
153	end:
154	return ret;
155	}
156
157	/*
158	* Allocate a random string, must be freed by the caller.
159	*/
160	static
161	char *random_session_name()
162	{
163	uint64_t id;
164	char *str = NULL;
165	int ret;
166
167	FILE *f = fopen( "/dev/urandom", "r");
168	if (!f) {
169	perror("fopen");
170	goto end;
171	}
172
173	ret = fread(&id, 1, sizeof(uint64_t), f);
174	if (ret < sizeof(id)) {
175	perror("fread");
176	goto end;
177	}
178
179	ret = asprintf(&str, "lttngtop-%" PRIu64, id);
180	if (ret < 0) {
181	fprintf(stderr, "Error allocating session name");
182	str = NULL;
183	goto end;
184	}
185
186	ret = fclose(f);
187	if (ret != 0) {
188	perror("fclose");
189	goto end;
190	}
191
192	end:
193	return str;
194	}
195
196	static
197	int check_session_name(char *name, int sudo)
198	{
199	int ret;
200	char cmd[1024];
201
202	ret = sprintf(cmd, "%s lttng list \| grep %s >/dev/null",
203	(sudo) ? "sudo" : " ", name);
204	if (ret < 0) {
205	fprintf(stderr, "Allocating cmd\n");
206	goto end;
207	}
208
209	ret = (system(cmd));
210	if (ret == 0) {
211	fprintf(stderr, "Error: session %s already exist, either we "
212	"are not random enough or something is "
213	"really wrong\n", name);
214	ret = -1;
215	goto end;
216	}
217
218	end:
219	return ret;
220	}
221
222	static
223	int local_session(char *name, int sudo)
224	{
225	int ret;
226	char cmd[1024];
227
228	ret = sprintf(cmd, "%s lttng create %s >/dev/null",
229	(sudo) ? "sudo" : " ", name);
230	if (ret < 0) {
231	fprintf(stderr, "Allocating cmd\n");
232	goto end;
233	}
234	ret = (system(cmd));
235	if (ret != 0) {
236	fprintf(stderr, "Error: creating the session\n");
237	ret = -1;
238	goto end;
239	}
240
241	end:
242	return ret;
243	}
244
245	static
26d63ddf JD	246	int live_local_session(char *name, int sudo)
	247	{
	248	int ret;
	249	char cmd[1024];
	250
	251	ret = sprintf(cmd, "%s lttng create %s --live 1000000 -U net://localhost >/dev/null",
	252	(sudo) ? "sudo" : " ", name);
	253	if (ret < 0) {
	254	fprintf(stderr, "Allocating cmd\n");
	255	goto end;
	256	}
	257	ret = (system(cmd));
	258	if (ret != 0) {
	259	fprintf(stderr, "Error: creating the session\n");
	260	ret = -1;
	261	goto end;
	262	}
	263
	264	end:
	265	return ret;
	266	}
	267
	268	static
	269	int enable_events(char *name, int sudo)
f248b7d8 JD	270	{
	271	int ret;
	272	char cmd[1024];
	273
	274	ret = sprintf(cmd, "%s lttng enable-event -s %s -k %s >/dev/null",
	275	(sudo) ? "sudo" : " ", name, event_list);
	276	if (ret < 0) {
	277	fprintf(stderr, "Allocating cmd\n");
	278	goto end;
	279	}
	280
	281	ret = (system(cmd));
	282	if (ret != 0) {
	283	fprintf(stderr, "Error: enabling events\n");
	284	ret = -1;
	285	goto end;
	286	}
	287
	288	end:
	289	return ret;
	290	}
	291
	292	static
	293	int add_contexts(char *name, int sudo)
	294	{
	295	int ret;
	296	char cmd[1024];
	297
	298	ret = sprintf(cmd, "%s lttng add-context -s %s -k %s >/dev/null",
	299	(sudo) ? "sudo" : " ", name, context_list);
	300	if (ret < 0) {
	301	fprintf(stderr, "allocating cmd\n");
	302	goto end;
	303	}
	304
	305	ret = (system(cmd));
	306	if (ret != 0) {
	307	fprintf(stderr, "error: adding contexts\n");
	308	ret = -1;
	309	goto end;
	310	}
	311
	312	end:
	313	return ret;
	314	}
	315
	316	static
26d63ddf	317	int start(char *name, int sudo, int local)
f248b7d8 JD	318	{
	319	int ret;
	320	char cmd[1024];
	321
	322	ret = sprintf(cmd, "%s lttng start %s >/dev/null",
	323	(sudo) ? "sudo" : " ", name);
	324	if (ret < 0) {
	325	fprintf(stderr, "allocating cmd\n");
	326	goto end;
	327	}
	328
	329	ret = (system(cmd));
	330	if (ret != 0) {
	331	fprintf(stderr, "error: starting the session %s\n", name);
	332	ret = -1;
	333	goto end;
	334	}
	335
26d63ddf JD	336	if (local) {
	337	ret = sprintf(cmd, "%s lttng list\|grep %s\|cut -d'(' -f2\|cut -d ')' -f1",
	338	(sudo) ? "sudo" : " ", name);
	339	} else {
	340	ret = sprintf(cmd, "lttngtop -r net://localhost\|grep %s\|cut -d' ' -f1",
	341	name);
	342	}
f248b7d8 JD	343	if (ret < 0) {
	344	fprintf(stderr, "allocating cmd\n");
	345	goto end;
	346	}
26d63ddf JD	347	fprintf(stderr, "%s session started : ",
26d63ddf JD	348	(local) ? "Local" : "Live");
f248b7d8 JD	349	ret = (system(cmd));
	350	if (ret != 0) {
	351	fprintf(stderr, "error: listing the sessions\n");
	352	ret = -1;
	353	goto end;
	354	}
	355
	356	end:
	357	return ret;
	358	}
	359
	360	static
26d63ddf	361	int destroy(char *name)
f248b7d8 JD	362	{
f248b7d8 JD	363	int ret;
26d63ddf	364	int sudo = 0;
f248b7d8 JD	365	char cmd[1024];
f248b7d8 JD	366
26d63ddf JD	367	if (getuid() != 0) {
	368	ret = system("sudo -l lttng >/dev/null");
	369	if (ret < 0) {
	370	fprintf(stderr, "[error] You are not root and not "
	371	"allowed by sudo to use lttng\n");
	372	ret = -1;
	373	goto end;
	374	}
	375	sudo = 1;
	376	}
	377
f248b7d8 JD	378	ret = sprintf(cmd, "%s lttng destroy %s >/dev/null",
	379	(sudo) ? "sudo" : " ", name);
	380	if (ret < 0) {
	381	fprintf(stderr, "allocating cmd\n");
	382	goto end;
	383	}
	384
	385	ret = (system(cmd));
	386	if (ret != 0) {
	387	fprintf(stderr, "error: destroying the session %s\n", name);
	388	ret = -1;
	389	goto end;
	390	}
	391
	392	end:
	393	return ret;
	394	}
	395
	396	int create_local_session()
	397	{
	398	int ret;
	399	char *name;
	400	int sudo = 0;
	401
	402	ret = check_requirements(&sudo);
	403
	404	name = random_session_name();
	405	if (!name) {
	406	ret = -1;
	407	goto end;
	408	}
	409
	410	ret = check_session_name(name, sudo);
	411	if (ret < 0) {
	412	goto end_free;
	413	}
	414
	415	ret = local_session(name, sudo);
	416	if (ret < 0) {
	417	goto end_free;
	418	}
	419
26d63ddf	420	ret = enable_events(name, sudo);
f248b7d8 JD	421	if (ret < 0) {
	422	goto end_free;
	423	}
	424
	425	ret = add_contexts(name, sudo);
	426	if (ret < 0) {
	427	goto end_free;
	428	}
	429
26d63ddf	430	ret = start(name, sudo, 1);
f248b7d8 JD	431	if (ret < 0) {
	432	goto end_free;
	433	}
	434
	435	end_free:
	436	free(name);
	437	end:
	438	return ret;
	439	}
	440
26d63ddf JD	441	int destroy_session(char *name)
	442	{
	443	return destroy(name);
	444	}
	445
	446	int create_live_local_session()
f248b7d8	447	{
26d63ddf JD	448	int ret;
	449	char *name;
	450	int sudo = 0;
	451
	452	ret = check_requirements(&sudo);
	453
	454	name = random_session_name();
	455	if (!name) {
	456	ret = -1;
	457	goto end;
	458	}
	459
	460	ret = check_session_name(name, sudo);
	461	if (ret < 0) {
	462	goto end_free;
	463	}
	464
	465	ret = live_local_session(name, sudo);
	466	if (ret < 0) {
	467	goto end_free;
	468	}
	469
	470	ret = enable_events(name, sudo);
	471	if (ret < 0) {
	472	goto end_free;
	473	}
	474
	475	ret = add_contexts(name, sudo);
	476	if (ret < 0) {
	477	goto end_free;
	478	}
	479
	480	ret = start(name, sudo, 0);
	481	if (ret < 0) {
	482	goto end_free;
	483	}
	484
	485	end_free:
	486	free(name);
	487	end:
	488	return ret;
f248b7d8 JD	489	}
	490
	491	/*
	492	int create_live_local_session();
	493	int destroy_live_local_session();
	494	*/