[ust.git] / libtracectl / tracectl.c

#include <stdio.h>
#include <stdint.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sched.h>
#include <fcntl.h>

#include "marker.h"
#include "tracer.h"
#include "usterr.h"

#define UNIX_PATH_MAX 108

//#define SOCKETDIR "/var/run/ust/socks"
#define SOCKETDIR "/tmp/socks"
#define SOCKETDIRLEN sizeof(SOCKETDIR)
#define USTSIGNAL SIGIO

#define MAX_MSG_SIZE (100)
#define MSG_NOTIF 1
#define MSG_REGISTER_NOTIF 2

char consumer_stack[10000];

struct tracecmd { /* no padding */
	uint32_t size;
	uint16_t command;
};

//struct listener_arg {
//	int pipe_fd;
//};

struct trctl_msg {
	/* size: the size of all the fields except size itself */
	uint32_t size;
	uint16_t type;
	/* Only the necessary part of the payload is transferred. It
         * may even be none of it.
         */
	char payload[94];
};

pid_t mypid;
char mysocketfile[UNIX_PATH_MAX] = "";
int pfd = -1;

struct consumer_channel {
	int fd;
	struct ltt_channel_struct *chan;
};

int consumer(void *arg)
{
	int result;
	int fd;
	char str[] = "Hello, this is the consumer.\n";
	struct ltt_trace_struct *trace;
	struct consumer_channel *consumer_channels;
	int i;
	char trace_name[] = "auto";

	ltt_lock_traces();
	trace = _ltt_trace_find(trace_name);
	ltt_unlock_traces();

	if(trace == NULL) {
		CPRINTF("cannot find trace!");
		return 1;
	}

	consumer_channels = (struct consumer_channel *) malloc(trace->nr_channels * sizeof(struct consumer_channel));
	if(consumer_channels == NULL) {
		ERR("malloc returned NULL");
		return 1;
	}

	CPRINTF("opening trace files");
	for(i=0; i<trace->nr_channels; i++) {
		char tmp[100];
		struct ltt_channel_struct *chan = &trace->channels[i];

		consumer_channels[i].chan = chan;

		snprintf(tmp, sizeof(tmp), "trace/%s_0", chan->channel_name);
		result = consumer_channels[i].fd = open(tmp, O_WRONLY | O_CREAT | O_TRUNC, 00644);
		if(result == -1) {
			perror("open");
			return -1;
		}
		CPRINTF("\topened trace file %s", tmp);
		
	}
	CPRINTF("done opening trace files");

	for(;;) {
		/*wait*/

		for(i=0; i<trace->nr_channels; i++) {
			struct rchan *rchan = consumer_channels[i].chan->trans_channel_data;
			struct rchan_buf *rbuf = rchan->buf;
			struct ltt_channel_buf_struct *lttbuf = consumer_channels[i].chan->buf;
			long consumed_old;

			result = ltt_do_get_subbuf(rbuf, lttbuf, &consumed_old);
			if(result < 0) {
				DBG("ltt_do_get_subbuf: error: %s", strerror(-result));
			}
			else {
				DBG("success!");

				result = write(consumer_channels[i].fd, rbuf->buf_data + (consumed_old & (2 * 4096-1)), 4096);
				ltt_do_put_subbuf(rbuf, lttbuf, consumed_old);
			}
		}

		sleep(1);
	}

//	CPRINTF("consumer: got a trace: %s with %d channels\n", trace_name, trace->nr_channels);
//
//	struct ltt_channel_struct *chan = &trace->channels[0];
//
//	CPRINTF("channel 1 (%s) active=%u", chan->channel_name, chan->active & 1);

//	struct rchan *rchan = chan->trans_channel_data;
//	struct rchan_buf *rbuf = rchan->buf;
//	struct ltt_channel_buf_struct *lttbuf = chan->buf;
//	long consumed_old;
//
//	result = fd = open("trace.out", O_WRONLY | O_CREAT | O_TRUNC, 00644);
//	if(result == -1) {
//		perror("open");
//		return -1;
//	}

//	for(;;) {
//		write(STDOUT_FILENO, str, sizeof(str));
//
//		result = ltt_do_get_subbuf(rbuf, lttbuf, &consumed_old);
//		if(result < 0) {
//			CPRINTF("ltt_do_get_subbuf: error: %s", strerror(-result));
//		}
//		else {
//			CPRINTF("success!");
//
//			result = write(fd, rbuf->buf_data + (consumed_old & (2 * 4096-1)), 4096);
//			ltt_do_put_subbuf(rbuf, lttbuf, consumed_old);
//		}
//
//		//CPRINTF("There seems to be %ld bytes available", SUBBUF_TRUNC(local_read(&lttbuf->offset), rbuf->chan) - consumed_old);
//		CPRINTF("Commit count %ld", local_read(&lttbuf->commit_count[0]));
//
//
//		sleep(1);
//	}
}

void start_consumer(void)
{
	int result;

	result = clone(consumer, consumer_stack+sizeof(consumer_stack)-1, CLONE_FS | CLONE_FILES | CLONE_VM | CLONE_SIGHAND | CLONE_THREAD, NULL);
	if(result == -1) {
		perror("clone");
	}
}

static void print_markers(void)
{
	struct marker_iter iter;

	marker_iter_reset(&iter);
	marker_iter_start(&iter);

	while(iter.marker) {
		fprintf(stderr, "marker: %s_%s \"%s\"\n", iter.marker->channel, iter.marker->name, iter.marker->format);
		marker_iter_next(&iter);
	}
}

void do_command(struct tracecmd *cmd)
{
}

void receive_commands()
{
}

int fd_notif = -1;
void notif_cb(void)
{
	int result;
	struct trctl_msg msg;

	/* FIXME: fd_notif should probably be protected by a spinlock */

	if(fd_notif == -1)
		return;

	msg.type = MSG_NOTIF;
	msg.size = sizeof(msg.type);

	/* FIXME: don't block here */
	result = write(fd_notif, &msg, msg.size+sizeof(msg.size));
	if(result == -1) {
		PERROR("write");
		return;
	}
}

char recvbuf[10000];

int listener_main(void *p)
{
	int result;

	for(;;) {
		uint32_t size;
		struct sockaddr_un addr;
		socklen_t addrlen = sizeof(addr);
		char trace_name[] = "auto";
		char trace_type[] = "ustrelay";

		for(;;) {
			struct trctl_msg msg;
			int len;

			result = len = recvfrom(pfd, recvbuf, sizeof(recvbuf), 0, &addr, &addrlen);
			if(result == -1) {
				PERROR("recvfrom");
				continue;
			}

			if(recvbuf[len-1] == '\n')
				recvbuf[len-1] = '\0';

			fprintf(stderr, "received a message! it's: %s\n", recvbuf);


			if(!strcmp(recvbuf, "print_markers")) {
				print_markers();
			}
			else if(!strcmp(recvbuf, "trace_setup")) {
				DBG("trace setup");

				result = ltt_trace_setup(trace_name);
				if(result < 0) {
					ERR("ltt_trace_setup failed");
					return;
				}

				result = ltt_trace_set_type(trace_name, trace_type);
				if(result < 0) {
					ERR("ltt_trace_set_type failed");
					return;
				}
			}
			else if(!strcmp(recvbuf, "trace_alloc")) {
				DBG("trace alloc");

				result = ltt_trace_alloc(trace_name);
				if(result < 0) {
					ERR("ltt_trace_alloc failed");
					return;
				}
			}
			else if(!strcmp(recvbuf, "trace_start")) {
				DBG("trace start");

				result = ltt_trace_start(trace_name);
				if(result < 0) {
					ERR("ltt_trace_start failed");
					return;
				}
			}
			else if(!strcmp(recvbuf, "trace_stop")) {
				DBG("trace stop");

				result = ltt_trace_stop(trace_name);
				if(result < 0) {
					ERR("ltt_trace_stop failed");
					return;
				}
			}
			else if(!strcmp(recvbuf, "trace_destroy")) {

				DBG("trace destroy");

				result = ltt_trace_destroy(trace_name);
				if(result < 0) {
					ERR("ltt_trace_destroy failed");
					return;
				}
			}
		}
		next_conn:;
	}
}

void create_listener(void)
{
	int result;
	static char listener_stack[16384];

	result = clone(listener_main, listener_stack+sizeof(listener_stack)-1, CLONE_FS | CLONE_FILES | CLONE_VM | CLONE_SIGHAND | CLONE_THREAD, NULL);
	if(result == -1) {
		perror("clone");
	}
}

/* The signal handler itself. */

void sighandler(int sig)
{
	DBG("sighandler");
	create_listener();
}

/* Called by the app signal handler to chain it to us. */

void chain_signal(void)
{
	sighandler(USTSIGNAL);
}

static int init_socket(void)
{
	int result;
	int fd;
	char pidstr[6];
	int pidlen;

	struct sockaddr_un addr;
	
	result = fd = socket(PF_UNIX, SOCK_DGRAM, 0);
	if(result == -1) {
		PERROR("socket");
		return -1;
	}

	addr.sun_family = AF_UNIX;

	result = snprintf(addr.sun_path, UNIX_PATH_MAX, "%s/%d", SOCKETDIR, mypid);
	if(result >= UNIX_PATH_MAX) {
		ERR("string overflow allocating socket name");
		goto close_sock;
	}
	//DBG("opening socket at %s", addr.sun_path);

	result = bind(fd, (struct sockaddr *)&addr, sizeof(addr));
	if(result == -1) {
		PERROR("bind");
		goto close_sock;
	}

	strcpy(mysocketfile, addr.sun_path);

	pfd = fd;
	return 0;

	close_sock:
	close(fd);

	return -1;
}

static void destroy_socket(void)
{
	int result;

	if(mysocketfile[0] == '\0')
		return;

	result = unlink(mysocketfile);
	if(result == -1) {
		PERROR("unlink");
	}
}

static int init_signal_handler(void)
{
	/* Attempt to handler SIGIO. If the main program wants to
	 * handle it, fine, it'll override us. They it'll have to
	 * use the chaining function.
	 */

	int result;
	struct sigaction act;

	result = sigemptyset(&act.sa_mask);
	if(result == -1) {
		PERROR("sigemptyset");
		return -1;
	}

	act.sa_handler = sighandler;
	act.sa_flags = SA_RESTART;

	/* Only defer ourselves. Also, try to restart interrupted
	 * syscalls to disturb the traced program as little as possible.
	 */
	result = sigaction(SIGIO, &act, NULL);
	if(result == -1) {
		PERROR("sigaction");
		return -1;
	}

	return 0;
}

static void auto_probe_connect(struct marker *m)
{
	int result;

	result = ltt_marker_connect(m->channel, m->name, "default");
	if(result)
		ERR("ltt_marker_connect");

	DBG("just auto connected marker %s %s to probe default", m->channel, m->name);
}

static void __attribute__((constructor(101))) init0()
{
	DBG("UST_AUTOPROBE constructor");
	if(getenv("UST_AUTOPROBE")) {
		marker_set_new_marker_cb(auto_probe_connect);
	}
}

static void fini(void);

static void __attribute__((constructor(1000))) init()
{
	int result;

	DBG("UST_TRACE constructor");

	mypid = getpid();

	if(getenv("UST_TRACE")) {
		char trace_name[] = "auto";
		char trace_type[] = "ustrelay";

		DBG("starting early tracing");

		/* Ensure marker control is initialized */
		init_marker_control();

		/* Ensure relay is initialized */
		init_ustrelay_transport();

		/* Ensure markers are initialized */
		init_markers();

		/* In case. */
		ltt_channels_register("ust");

		result = ltt_trace_setup(trace_name);
		if(result < 0) {
			ERR("ltt_trace_setup failed");
			return;
		}

		result = ltt_trace_set_type(trace_name, trace_type);
		if(result < 0) {
			ERR("ltt_trace_set_type failed");
			return;
		}

		result = ltt_trace_alloc(trace_name);
		if(result < 0) {
			ERR("ltt_trace_alloc failed");
			return;
		}

		result = ltt_trace_start(trace_name);
		if(result < 0) {
			ERR("ltt_trace_start failed");
			return;
		}
		start_consumer();
	}

	/* Must create socket before signal handler to prevent races
         * on pfd variable.
         */
	result = init_socket();
	if(result == -1) {
		ERR("init_socket error");
		return;
	}
	result = init_signal_handler();
	if(result == -1) {
		ERR("init_signal_handler error");
		return;
	}

	return;

	/* should decrementally destroy stuff if error */

}

/* This is only called if we terminate normally, not with an unhandled signal,
 * so we cannot rely on it. */

static void __attribute__((destructor)) fini()
{
	int result;

	/* if trace running, finish it */

	DBG("destructor stopping traces");

	result = ltt_trace_stop("auto");
	if(result == -1) {
		ERR("ltt_trace_stop error");
	}

	result = ltt_trace_destroy("auto");
	if(result == -1) {
		ERR("ltt_trace_destroy error");
	}

	/* FIXME: wait for the consumer to be done */
	sleep(3);

	destroy_socket();
}
Commit	Line	Data
68c1021b PMF	1	#include <stdio.h>
	2	#include <stdint.h>
	3	#include <signal.h>
	4	#include <sys/types.h>
	5	#include <sys/socket.h>
	6	#include <sys/un.h>
98963de4	7	#include <sched.h>
a584bc4e	8	#include <fcntl.h>
fbd8191b PMF	9
fbd8191b PMF	10	#include "marker.h"
a584bc4e PMF	11	#include "tracer.h"
a584bc4e PMF	12	#include "usterr.h"
fbd8191b	13
68c1021b PMF	14	#define UNIX_PATH_MAX 108
	15
	16	//#define SOCKETDIR "/var/run/ust/socks"
	17	#define SOCKETDIR "/tmp/socks"
	18	#define SOCKETDIRLEN sizeof(SOCKETDIR)
	19	#define USTSIGNAL SIGIO
	20
98963de4 PMF	21	#define MAX_MSG_SIZE (100)
	22	#define MSG_NOTIF 1
	23	#define MSG_REGISTER_NOTIF 2
	24
a584bc4e PMF	25	char consumer_stack[10000];
a584bc4e PMF	26
68c1021b PMF	27	struct tracecmd { /* no padding */
	28	uint32_t size;
	29	uint16_t command;
	30	};
	31
98963de4 PMF	32	//struct listener_arg {
	33	// int pipe_fd;
	34	//};
	35
	36	struct trctl_msg {
	37	/* size: the size of all the fields except size itself */
	38	uint32_t size;
	39	uint16_t type;
	40	/* Only the necessary part of the payload is transferred. It
	41	* may even be none of it.
	42	*/
	43	char payload[94];
	44	};
68c1021b PMF	45
	46	pid_t mypid;
	47	char mysocketfile[UNIX_PATH_MAX] = "";
98963de4	48	int pfd = -1;
68c1021b	49
a584bc4e PMF	50	struct consumer_channel {
	51	int fd;
	52	struct ltt_channel_struct *chan;
	53	};
	54
	55	int consumer(void *arg)
	56	{
	57	int result;
	58	int fd;
	59	char str[] = "Hello, this is the consumer.\n";
	60	struct ltt_trace_struct *trace;
	61	struct consumer_channel *consumer_channels;
	62	int i;
	63	char trace_name[] = "auto";
	64
	65	ltt_lock_traces();
	66	trace = _ltt_trace_find(trace_name);
	67	ltt_unlock_traces();
	68
	69	if(trace == NULL) {
	70	CPRINTF("cannot find trace!");
	71	return 1;
	72	}
	73
	74	consumer_channels = (struct consumer_channel ) malloc(trace->nr_channels sizeof(struct consumer_channel));
	75	if(consumer_channels == NULL) {
	76	ERR("malloc returned NULL");
	77	return 1;
	78	}
	79
	80	CPRINTF("opening trace files");
	81	for(i=0; i<trace->nr_channels; i++) {
	82	char tmp[100];
	83	struct ltt_channel_struct *chan = &trace->channels[i];
	84
	85	consumer_channels[i].chan = chan;
	86
1c184644	87	snprintf(tmp, sizeof(tmp), "trace/%s_0", chan->channel_name);
a584bc4e PMF	88	result = consumer_channels[i].fd = open(tmp, O_WRONLY \| O_CREAT \| O_TRUNC, 00644);
	89	if(result == -1) {
	90	perror("open");
	91	return -1;
	92	}
	93	CPRINTF("\topened trace file %s", tmp);
	94
	95	}
	96	CPRINTF("done opening trace files");
	97
	98	for(;;) {
	99	/wait/
	100
	101	for(i=0; i<trace->nr_channels; i++) {
	102	struct rchan *rchan = consumer_channels[i].chan->trans_channel_data;
	103	struct rchan_buf *rbuf = rchan->buf;
	104	struct ltt_channel_buf_struct *lttbuf = consumer_channels[i].chan->buf;
	105	long consumed_old;
	106
	107	result = ltt_do_get_subbuf(rbuf, lttbuf, &consumed_old);
	108	if(result < 0) {
1c184644	109	DBG("ltt_do_get_subbuf: error: %s", strerror(-result));
a584bc4e PMF	110	}
a584bc4e PMF	111	else {
1c184644	112	DBG("success!");
a584bc4e PMF	113
	114	result = write(consumer_channels[i].fd, rbuf->buf_data + (consumed_old & (2 * 4096-1)), 4096);
	115	ltt_do_put_subbuf(rbuf, lttbuf, consumed_old);
	116	}
	117	}
	118
	119	sleep(1);
	120	}
	121
	122	// CPRINTF("consumer: got a trace: %s with %d channels\n", trace_name, trace->nr_channels);
	123	//
	124	// struct ltt_channel_struct *chan = &trace->channels[0];
	125	//
	126	// CPRINTF("channel 1 (%s) active=%u", chan->channel_name, chan->active & 1);
	127
	128	// struct rchan *rchan = chan->trans_channel_data;
	129	// struct rchan_buf *rbuf = rchan->buf;
	130	// struct ltt_channel_buf_struct *lttbuf = chan->buf;
	131	// long consumed_old;
	132	//
	133	// result = fd = open("trace.out", O_WRONLY \| O_CREAT \| O_TRUNC, 00644);
	134	// if(result == -1) {
	135	// perror("open");
	136	// return -1;
	137	// }
	138
	139	// for(;;) {
	140	// write(STDOUT_FILENO, str, sizeof(str));
	141	//
	142	// result = ltt_do_get_subbuf(rbuf, lttbuf, &consumed_old);
	143	// if(result < 0) {
	144	// CPRINTF("ltt_do_get_subbuf: error: %s", strerror(-result));
	145	// }
	146	// else {
	147	// CPRINTF("success!");
	148	//
	149	// result = write(fd, rbuf->buf_data + (consumed_old & (2 * 4096-1)), 4096);
	150	// ltt_do_put_subbuf(rbuf, lttbuf, consumed_old);
	151	// }
	152	//
	153	// //CPRINTF("There seems to be %ld bytes available", SUBBUF_TRUNC(local_read(&lttbuf->offset), rbuf->chan) - consumed_old);
	154	// CPRINTF("Commit count %ld", local_read(&lttbuf->commit_count[0]));
	155	//
	156	//
	157	// sleep(1);
	158	// }
	159	}
	160
	161	void start_consumer(void)
	162	{
	163	int result;
	164
	165	result = clone(consumer, consumer_stack+sizeof(consumer_stack)-1, CLONE_FS \| CLONE_FILES \| CLONE_VM \| CLONE_SIGHAND \| CLONE_THREAD, NULL);
	166	if(result == -1) {
	167	perror("clone");
	168	}
	169	}
fbd8191b PMF	170
	171	static void print_markers(void)
	172	{
	173	struct marker_iter iter;
	174
	175	marker_iter_reset(&iter);
	176	marker_iter_start(&iter);
	177
	178	while(iter.marker) {
	179	fprintf(stderr, "marker: %s_%s \"%s\"\n", iter.marker->channel, iter.marker->name, iter.marker->format);
	180	marker_iter_next(&iter);
	181	}
	182	}
	183
68c1021b PMF	184	void do_command(struct tracecmd *cmd)
	185	{
	186	}
	187
	188	void receive_commands()
	189	{
	190	}
	191
98963de4 PMF	192	int fd_notif = -1;
	193	void notif_cb(void)
	194	{
	195	int result;
	196	struct trctl_msg msg;
	197
	198	/* FIXME: fd_notif should probably be protected by a spinlock */
	199
	200	if(fd_notif == -1)
	201	return;
	202
	203	msg.type = MSG_NOTIF;
	204	msg.size = sizeof(msg.type);
	205
	206	/* FIXME: don't block here */
	207	result = write(fd_notif, &msg, msg.size+sizeof(msg.size));
	208	if(result == -1) {
	209	PERROR("write");
	210	return;
	211	}
	212	}
	213
fbd8191b PMF	214	char recvbuf[10000];
fbd8191b PMF	215
98963de4 PMF	216	int listener_main(void *p)
	217	{
	218	int result;
	219
98963de4	220	for(;;) {
98963de4	221	uint32_t size;
98963de4 PMF	222	struct sockaddr_un addr;
98963de4 PMF	223	socklen_t addrlen = sizeof(addr);
aafb1650 PMF	224	char trace_name[] = "auto";
aafb1650 PMF	225	char trace_type[] = "ustrelay";
98963de4	226
98963de4 PMF	227	for(;;) {
98963de4 PMF	228	struct trctl_msg msg;
fbd8191b	229	int len;
98963de4	230
fbd8191b	231	result = len = recvfrom(pfd, recvbuf, sizeof(recvbuf), 0, &addr, &addrlen);
98963de4	232	if(result == -1) {
fbd8191b	233	PERROR("recvfrom");
98963de4 PMF	234	continue;
	235	}
	236
aafb1650 PMF	237	if(recvbuf[len-1] == '\n')
aafb1650 PMF	238	recvbuf[len-1] = '\0';
98963de4	239
fbd8191b	240	fprintf(stderr, "received a message! it's: %s\n", recvbuf);
98963de4	241
fbd8191b PMF	242
	243	if(!strcmp(recvbuf, "print_markers")) {
	244	print_markers();
	245	}
	246	else if(!strcmp(recvbuf, "trace_setup")) {
	247	DBG("trace setup");
aafb1650 PMF	248
	249	result = ltt_trace_setup(trace_name);
	250	if(result < 0) {
	251	ERR("ltt_trace_setup failed");
	252	return;
	253	}
	254
	255	result = ltt_trace_set_type(trace_name, trace_type);
	256	if(result < 0) {
	257	ERR("ltt_trace_set_type failed");
	258	return;
	259	}
fbd8191b PMF	260	}
	261	else if(!strcmp(recvbuf, "trace_alloc")) {
	262	DBG("trace alloc");
aafb1650 PMF	263
	264	result = ltt_trace_alloc(trace_name);
	265	if(result < 0) {
	266	ERR("ltt_trace_alloc failed");
	267	return;
	268	}
fbd8191b PMF	269	}
	270	else if(!strcmp(recvbuf, "trace_start")) {
	271	DBG("trace start");
aafb1650 PMF	272
	273	result = ltt_trace_start(trace_name);
	274	if(result < 0) {
	275	ERR("ltt_trace_start failed");
	276	return;
	277	}
fbd8191b PMF	278	}
	279	else if(!strcmp(recvbuf, "trace_stop")) {
	280	DBG("trace stop");
aafb1650 PMF	281
	282	result = ltt_trace_stop(trace_name);
	283	if(result < 0) {
	284	ERR("ltt_trace_stop failed");
	285	return;
	286	}
	287	}
	288	else if(!strcmp(recvbuf, "trace_destroy")) {
	289
	290	DBG("trace destroy");
	291
	292	result = ltt_trace_destroy(trace_name);
	293	if(result < 0) {
	294	ERR("ltt_trace_destroy failed");
	295	return;
	296	}
fbd8191b	297	}
98963de4 PMF	298	}
	299	next_conn:;
	300	}
	301	}
	302
	303	void create_listener(void)
	304	{
	305	int result;
	306	static char listener_stack[16384];
	307
fbd8191b	308	result = clone(listener_main, listener_stack+sizeof(listener_stack)-1, CLONE_FS \| CLONE_FILES \| CLONE_VM \| CLONE_SIGHAND \| CLONE_THREAD, NULL);
98963de4 PMF	309	if(result == -1) {
	310	perror("clone");
	311	}
	312	}
	313
68c1021b PMF	314	/* The signal handler itself. */
	315
	316	void sighandler(int sig)
	317	{
	318	DBG("sighandler");
fbd8191b	319	create_listener();
68c1021b PMF	320	}
	321
	322	/* Called by the app signal handler to chain it to us. */
	323
98963de4	324	void chain_signal(void)
68c1021b PMF	325	{
	326	sighandler(USTSIGNAL);
	327	}
	328
98963de4	329	static int init_socket(void)
68c1021b PMF	330	{
	331	int result;
	332	int fd;
	333	char pidstr[6];
	334	int pidlen;
	335
	336	struct sockaddr_un addr;
	337
fbd8191b	338	result = fd = socket(PF_UNIX, SOCK_DGRAM, 0);
68c1021b PMF	339	if(result == -1) {
	340	PERROR("socket");
	341	return -1;
	342	}
	343
	344	addr.sun_family = AF_UNIX;
	345
	346	result = snprintf(addr.sun_path, UNIX_PATH_MAX, "%s/%d", SOCKETDIR, mypid);
	347	if(result >= UNIX_PATH_MAX) {
	348	ERR("string overflow allocating socket name");
	349	goto close_sock;
	350	}
	351	//DBG("opening socket at %s", addr.sun_path);
	352
	353	result = bind(fd, (struct sockaddr *)&addr, sizeof(addr));
	354	if(result == -1) {
	355	PERROR("bind");
	356	goto close_sock;
	357	}
	358
	359	strcpy(mysocketfile, addr.sun_path);
	360
98963de4 PMF	361	pfd = fd;
	362	return 0;
	363
68c1021b PMF	364	close_sock:
	365	close(fd);
	366
	367	return -1;
	368	}
	369
98963de4	370	static void destroy_socket(void)
68c1021b PMF	371	{
	372	int result;
	373
	374	if(mysocketfile[0] == '\0')
	375	return;
	376
	377	result = unlink(mysocketfile);
	378	if(result == -1) {
	379	PERROR("unlink");
	380	}
	381	}
	382
98963de4	383	static int init_signal_handler(void)
68c1021b PMF	384	{
	385	/* Attempt to handler SIGIO. If the main program wants to
	386	* handle it, fine, it'll override us. They it'll have to
	387	* use the chaining function.
	388	*/
	389
	390	int result;
	391	struct sigaction act;
	392
	393	result = sigemptyset(&act.sa_mask);
	394	if(result == -1) {
	395	PERROR("sigemptyset");
	396	return -1;
	397	}
	398
	399	act.sa_handler = sighandler;
	400	act.sa_flags = SA_RESTART;
	401
	402	/* Only defer ourselves. Also, try to restart interrupted
	403	* syscalls to disturb the traced program as little as possible.
	404	*/
	405	result = sigaction(SIGIO, &act, NULL);
	406	if(result == -1) {
	407	PERROR("sigaction");
	408	return -1;
	409	}
	410
	411	return 0;
	412	}
	413
20b37a31	414	static void auto_probe_connect(struct marker *m)
68c1021b PMF	415	{
	416	int result;
	417
20b37a31 PMF	418	result = ltt_marker_connect(m->channel, m->name, "default");
	419	if(result)
	420	ERR("ltt_marker_connect");
	421
	422	DBG("just auto connected marker %s %s to probe default", m->channel, m->name);
	423	}
	424
	425	static void __attribute__((constructor(101))) init0()
	426	{
	427	DBG("UST_AUTOPROBE constructor");
	428	if(getenv("UST_AUTOPROBE")) {
	429	marker_set_new_marker_cb(auto_probe_connect);
	430	}
	431	}
	432
a584bc4e PMF	433	static void fini(void);
a584bc4e PMF	434
20b37a31 PMF	435	static void __attribute__((constructor(1000))) init()
	436	{
	437	int result;
	438
	439	DBG("UST_TRACE constructor");
	440
68c1021b PMF	441	mypid = getpid();
68c1021b PMF	442
4db647c5 PMF	443	if(getenv("UST_TRACE")) {
	444	char trace_name[] = "auto";
	445	char trace_type[] = "ustrelay";
	446
	447	DBG("starting early tracing");
	448
	449	/* Ensure marker control is initialized */
	450	init_marker_control();
	451
	452	/* Ensure relay is initialized */
	453	init_ustrelay_transport();
	454
	455	/* Ensure markers are initialized */
	456	init_markers();
	457
20b37a31 PMF	458	/* In case. */
20b37a31 PMF	459	ltt_channels_register("ust");
4db647c5 PMF	460
	461	result = ltt_trace_setup(trace_name);
	462	if(result < 0) {
	463	ERR("ltt_trace_setup failed");
	464	return;
	465	}
	466
	467	result = ltt_trace_set_type(trace_name, trace_type);
	468	if(result < 0) {
	469	ERR("ltt_trace_set_type failed");
	470	return;
	471	}
	472
	473	result = ltt_trace_alloc(trace_name);
	474	if(result < 0) {
	475	ERR("ltt_trace_alloc failed");
	476	return;
	477	}
	478
	479	result = ltt_trace_start(trace_name);
	480	if(result < 0) {
	481	ERR("ltt_trace_start failed");
	482	return;
	483	}
a584bc4e	484	start_consumer();
4db647c5 PMF	485	}
4db647c5 PMF	486
98963de4 PMF	487	/* Must create socket before signal handler to prevent races
	488	* on pfd variable.
	489	*/
68c1021b	490	result = init_socket();
98963de4 PMF	491	if(result == -1) {
	492	ERR("init_socket error");
	493	return;
	494	}
	495	result = init_signal_handler();
	496	if(result == -1) {
	497	ERR("init_signal_handler error");
	498	return;
	499	}
68c1021b PMF	500
	501	return;
	502
	503	/* should decrementally destroy stuff if error */
	504
	505	}
	506
	507	/* This is only called if we terminate normally, not with an unhandled signal,
	508	* so we cannot rely on it. */
	509
98963de4	510	static void __attribute__((destructor)) fini()
68c1021b	511	{
a584bc4e PMF	512	int result;
	513
	514	/* if trace running, finish it */
	515
	516	DBG("destructor stopping traces");
	517
	518	result = ltt_trace_stop("auto");
	519	if(result == -1) {
	520	ERR("ltt_trace_stop error");
	521	}
	522
	523	result = ltt_trace_destroy("auto");
	524	if(result == -1) {
	525	ERR("ltt_trace_destroy error");
	526	}
	527
	528	/* FIXME: wait for the consumer to be done */
1c184644	529	sleep(3);
a584bc4e	530
68c1021b PMF	531	destroy_socket();
68c1021b PMF	532	}