Cleanup warnings

[lttng-ust.git] / tests / ust-basic-tracing / ust-basic-tracing.c

/*
 * ust-basic-tracing.c - Basic single-session, single-channel, single-process UST tracing
 *
 * Copyright (C) 2011 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 * 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 _LARGEFILE64_SOURCE
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <limits.h>
#include <urcu/futex.h>
#include <urcu/uatomic.h>
#include <assert.h>
#include <sys/socket.h>

#include "lttng-ust-comm.h"
#include "../../libringbuffer/backend.h"
#include "../../libringbuffer/frontend.h"

#define MAX_NR_STREAMS	64
#define MAX_NR_EVENTS	128

struct object_data {
	int handle;
	int shm_fd;
	int wait_fd;
	uint64_t memory_map_size;
};

static int session_handle;
static struct object_data metadata_stream_data;
static struct object_data metadata_data;
static struct object_data channel_data;
static struct object_data stream_data[MAX_NR_STREAMS];
static int event_handle[MAX_NR_EVENTS];

static int apps_socket = -1;
static char apps_sock_path[PATH_MAX];
static char local_apps_wait_shm_path[PATH_MAX];

static volatile int quit_program;

static void handle_signals(int signo)
{
	quit_program = 1;
}

static int send_app_msg(int sock, struct lttcomm_ust_msg *lum)
{
	ssize_t len;

	len = lttcomm_send_unix_sock(sock, lum, sizeof(*lum));
	switch (len) {
	case sizeof(*lum):
		printf("message successfully sent\n");
		break;
	case -1:
		if (errno == ECONNRESET) {
			printf("remote end closed connection\n");
			return 0;
		}
		return -1;
	default:
		printf("incorrect message size: %zd\n", len);
		return -1;
	}
	return 0;
}

static int recv_app_reply(int sock, struct lttcomm_ust_reply *lur,
			  uint32_t expected_handle, uint32_t expected_cmd)
{
	ssize_t len;

	memset(lur, 0, sizeof(*lur));
	len = lttcomm_recv_unix_sock(sock, lur, sizeof(*lur));
	switch (len) {
	case 0:	/* orderly shutdown */
		printf("Application has performed an orderly shutdown\n");
		return -EINVAL;
	case sizeof(*lur):
		printf("result message received\n");
		if (lur->handle != expected_handle) {
			printf("Unexpected result message handle\n");
			return -EINVAL;
		}

		if (lur->cmd != expected_cmd) {
			printf("Unexpected result message command\n");
			return -EINVAL;
		}
		if (lur->ret_code != LTTCOMM_OK) {
			printf("remote operation failed with code %d.\n",
				lur->ret_code);
			return lur->ret_code;
		}
		return 0;
	case -1:
		if (errno == ECONNRESET) {
			printf("remote end closed connection\n");
			return -EINVAL;
		}
		return -1;
	default:
		printf("incorrect message size: %zd\n", len);
		return len > 0 ? -1 : len;
	}
}

static int send_app_cmd(int sock,
			struct lttcomm_ust_msg *lum,
			struct lttcomm_ust_reply *lur)
{
	int ret;

	ret = send_app_msg(sock, lum);
	if (ret)
		return ret;
	ret = recv_app_reply(sock, lur, lum->handle, lum->cmd);
	if (ret)
		return ret;
	return 0;
}


/*
 * Receives a single fd from socket.
 *
 * Returns the size of received data
 */
static int lttcomm_recv_fd(int sock)
{
	struct iovec iov[1];
	int ret = 0;
	int data_fd;
	struct cmsghdr *cmsg;
	char recv_fd[CMSG_SPACE(sizeof(int))];
	struct msghdr msg = { 0 };

	/* Prepare to receive the structures */
	iov[0].iov_base = &data_fd;
	iov[0].iov_len = sizeof(data_fd);
	msg.msg_iov = iov;
	msg.msg_iovlen = 1;
	msg.msg_control = recv_fd;
	msg.msg_controllen = sizeof(recv_fd);

	printf("Waiting to receive fd\n");
	if ((ret = recvmsg(sock, &msg, 0)) < 0) {
		perror("recvmsg");
		goto end;
	}
	if (ret != sizeof(data_fd)) {
		printf("Received %d bytes, expected %ld", ret, sizeof(data_fd));
		goto end;
	}
	cmsg = CMSG_FIRSTHDR(&msg);
	if (!cmsg) {
		printf("Invalid control message header\n");
		ret = -1;
		goto end;
	}
	if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS) {
		printf("Didn't received any fd\n");
		ret = -1;
		goto end;
	}
	/* this is our fd */
	ret = ((int *) CMSG_DATA(cmsg))[0];
	printf("received fd %d\n", ret);
end:
	return ret;
}


static
int open_streams(int sock, int channel_handle, struct object_data *stream_datas,
		int nr_check)
{
	int ret, k = 0;

	for (;;) {
		struct lttcomm_ust_msg lum;
		struct lttcomm_ust_reply lur;

		memset(&lum, 0, sizeof(lum));
		lum.handle = channel_handle;
		lum.cmd = LTTNG_UST_STREAM;
		ret = send_app_cmd(sock, &lum, &lur);
		if (!ret) {
			assert(k < nr_check);
			stream_datas[k].handle = lur.ret_val;
			printf("received stream handle %u\n",
				stream_datas[k].handle);
			if (lur.ret_code == LTTCOMM_OK) {
				ssize_t len;

				stream_datas[k].memory_map_size = lur.u.stream.memory_map_size;
				/* get shm fd */
				len = lttcomm_recv_fd(sock);
				if (len < 0)
					return -EINVAL;
				stream_datas[k].shm_fd = len;
				/* get wait fd */
				len = lttcomm_recv_fd(sock);
				if (len < 0)
					return -EINVAL;
				stream_datas[k].wait_fd = len;
			}
			k++;
		}
		if (ret == -ENOENT)
			break;
		if (ret)
			return ret;
	}
	return 0;
}

static
int close_streams(int sock, struct object_data *stream_datas, int nr_check)
{
	int ret, k;

	for (k = 0; k < nr_check; k++) {
		struct lttcomm_ust_msg lum;
		struct lttcomm_ust_reply lur;

		if (!stream_datas[k].handle)
			continue;
		memset(&lum, 0, sizeof(lum));
		lum.handle = stream_datas[k].handle;
		lum.cmd = LTTNG_UST_RELEASE;
		ret = send_app_cmd(sock, &lum, &lur);
		if (ret) {
			printf("Error closing stream\n");
			return ret;
		}
		if (stream_datas[k].shm_fd >= 0) {
			ret = close(stream_datas[k].shm_fd);
			if (ret) {
				printf("Error closing stream shm_fd\n");
				return ret;
			}
		}
		if (stream_datas[k].wait_fd >= 0) {
			ret = close(stream_datas[k].wait_fd);
			if (ret) {
				printf("Error closing stream wait_fd\n");
				return ret;
			}
		}
	}
	return 0;
}

static
struct shm_handle *map_channel(struct object_data *chan_data,
		struct object_data *stream_datas, int nr_check)
{
	struct shm_handle *handle;
	struct channel *chan;
	int k, ret;

	/* map metadata channel */
	handle = channel_handle_create(chan_data->shm_fd,
		chan_data->wait_fd,
		chan_data->memory_map_size);
	if (!handle) {
		printf("create handle error\n");
		return NULL;
	}
	chan_data->shm_fd = -1;
	chan_data->wait_fd = -1;
	chan = shmp(handle, handle->chan);

	for (k = 0; k < nr_check; k++) {
		struct object_data *stream_data = &stream_datas[k];

		if (!stream_data->handle)
			break;
		/* map stream */
		ret = channel_handle_add_stream(handle,
			stream_data->shm_fd,
			stream_data->wait_fd,
			stream_data->memory_map_size);
		if (ret) {
			printf("add stream error\n");
			goto error_destroy;
		}
		stream_data->shm_fd = -1;
		stream_data->wait_fd = -1;
	}
	return handle;

error_destroy:
	channel_destroy(chan, handle, 1);
	return NULL;
}

static
void unmap_channel(struct shm_handle *handle)
{
	struct channel *chan;

	chan = shmp(handle, handle->chan);
	/* unmap channel */
	channel_destroy(chan, handle, 1);
}

static
int consume_stream(struct shm_handle *handle, int cpu, char *outfile)
{
	struct channel *chan;
	struct lib_ring_buffer *buf;
	int outfd, ret;
	int shm_fd, wait_fd;
	uint64_t memory_map_size;

	chan = shmp(handle, handle->chan);

	/* open stream */
	buf = channel_get_ring_buffer(&chan->backend.config,
		chan, cpu, handle, &shm_fd, &wait_fd, &memory_map_size);
	if (!buf)
		return -ENOENT;
	ret = lib_ring_buffer_open_read(buf, handle, 1);
	if (ret) {
		return -1;
	}

	/* copy */
	outfd = open(outfile, O_WRONLY | O_CREAT | O_LARGEFILE | O_TRUNC,
			S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
	if (outfd < 0) {
		perror("open output");
		return -1;
	}

	printf("Waiting for buffer data for %s\n", outfile);
	for (;;) {
		unsigned long read_size;
		unsigned long copy_size;
		char *ptr;

		ret = lib_ring_buffer_get_next_subbuf(buf, handle);
		printf("get next ret %d\n", ret);
		if (ret == -ENODATA)
			break;
		if (ret == -EAGAIN) {
			sleep(1);
			continue;
		}
		if (ret) {
			printf("Error %d in lib_ring_buffer_get_next_subbuf\n", ret);
			return -1;
		}
		read_size = lib_ring_buffer_get_read_data_size(
			&chan->backend.config, buf, handle);
		read_size = PAGE_ALIGN(read_size);
		ptr = lib_ring_buffer_read_offset_address(
			&buf->backend, 0, handle);
		printf("WRITE: copy %lu bytes\n", read_size);
		copy_size = write(outfd, ptr, read_size);
		if (copy_size < read_size) {
			printf("write issue: copied %zd, expected %lu\n", copy_size, read_size);
		}
		lib_ring_buffer_put_next_subbuf(buf, handle);
	}

	ret = close(outfd);
	if (ret) {
		perror("close");
		return -1;
	}

	/* close stream */
	lib_ring_buffer_release_read(buf, handle, 1);
	return 0;
}

static
int consume_buffers(const char *outputpath)
{
	int k, ret;
	mode_t old_umask;
	char pathname[PATH_MAX];
	struct shm_handle *handle;

	snprintf(pathname, PATH_MAX - 1, "%s", outputpath);
	old_umask = umask(0);
	ret = mkdir(pathname, S_IRWXU | S_IRWXG);
	if (ret && errno != EEXIST) {
		perror("mkdir");
		umask(old_umask);
		return -1;
	}
	umask(old_umask);

	/* copy metadata */
	handle = map_channel(&metadata_data,
			&metadata_stream_data, 1);
	if (!handle)
		return -1;
	snprintf(pathname, PATH_MAX - 1,
		"%s/metadata", outputpath);
	ret = consume_stream(handle, -1, pathname);
	if (ret && ret != -ENOENT) {
		printf("Error in consume_stream\n");
		return ret;
	}
	unmap_channel(handle);

	/* copy binary data */
	handle = map_channel(&channel_data,
			stream_data, MAX_NR_STREAMS);
	if (!handle)
		return -1;
	for (k = 0; k < MAX_NR_STREAMS; k++) {
		snprintf(pathname, PATH_MAX - 1,
			"%s/data_%u", outputpath, k);
		ret = consume_stream(handle, k, pathname);
		if (ret && ret != -ENOENT) {
			printf("Error in consume_stream\n");
			return ret;
		}
	}
	unmap_channel(handle);

	return 0;
}

int send_app_msgs(int sock, const char *outputpath,
		unsigned int nr_events, const char **event_names)
{
	struct lttcomm_ust_msg lum;
	struct lttcomm_ust_reply lur;
	int ret, k;

	/* Create session */
	memset(&lum, 0, sizeof(lum));
	lum.handle = LTTNG_UST_ROOT_HANDLE;
	lum.cmd = LTTNG_UST_SESSION;
	ret = send_app_cmd(sock, &lum, &lur);
	if (ret)
		return ret;
	session_handle = lur.ret_val;
	printf("received session handle %u\n", session_handle);

	/* Create metadata channel */
	memset(&lum, 0, sizeof(lum));
	lum.handle = session_handle;
	lum.cmd = LTTNG_UST_METADATA;
	lum.u.channel.overwrite = 0;
	lum.u.channel.subbuf_size = 32768;
	lum.u.channel.num_subbuf = 4;
	lum.u.channel.switch_timer_interval = 0;
	lum.u.channel.read_timer_interval = 0;
	lum.u.channel.output = LTTNG_UST_MMAP;
	ret = send_app_cmd(sock, &lum, &lur);
	if (ret)
		return ret;
	metadata_data.handle = lur.ret_val;
	printf("received metadata handle %u\n", metadata_data.handle);
	if (lur.ret_code == LTTCOMM_OK) {
		ssize_t len;

		metadata_data.memory_map_size = lur.u.channel.memory_map_size;
		/* get shm fd */
		len = lttcomm_recv_fd(sock);
		if (len < 0)
			return -EINVAL;
		metadata_data.shm_fd = len;
		/* get wait fd */
		len = lttcomm_recv_fd(sock);
		if (len < 0)
			return -EINVAL;
		metadata_data.wait_fd = len;
	}

	ret = open_streams(sock, metadata_data.handle,
			&metadata_stream_data, 1);
	if (ret) {
		printf("Error in open_streams\n");
		return ret;
	}

	/* Create data channel */
	memset(&lum, 0, sizeof(lum));
	lum.handle = session_handle;
	lum.cmd = LTTNG_UST_CHANNEL;
	//lum.u.channel.overwrite = 0;
	lum.u.channel.overwrite = 1;
	lum.u.channel.subbuf_size = 32768;
	lum.u.channel.num_subbuf = 8;
	//lum.u.channel.num_subbuf = 4;
	//lum.u.channel.num_subbuf = 2;
	lum.u.channel.switch_timer_interval = 0;
	lum.u.channel.read_timer_interval = 0;
	lum.u.channel.output = LTTNG_UST_MMAP;
	ret = send_app_cmd(sock, &lum, &lur);
	if (ret)
		return ret;
	channel_data.handle = lur.ret_val;
	printf("received channel handle %u\n", channel_data.handle);
	if (lur.ret_code == LTTCOMM_OK) {
		ssize_t len;

		channel_data.memory_map_size = lur.u.channel.memory_map_size;
		/* get shm fd */
		len = lttcomm_recv_fd(sock);
		if (len < 0)
			return -EINVAL;
		channel_data.shm_fd = len;
		/* get wait fd */
		len = lttcomm_recv_fd(sock);
		if (len < 0)
			return -EINVAL;
		channel_data.wait_fd = len;
	}

	/* Create events */
	for (k = 0; k < nr_events; k++) {
		memset(&lum, 0, sizeof(lum));
		lum.handle = channel_data.handle;
		lum.cmd = LTTNG_UST_EVENT;
		strncpy(lum.u.event.name, event_names[k],
			LTTNG_UST_SYM_NAME_LEN);
		lum.u.event.instrumentation = LTTNG_UST_TRACEPOINT;
		ret = send_app_cmd(sock, &lum, &lur);
		if (ret)
			return ret;
		event_handle[k] = lur.ret_val;
		printf("received event handle %u\n", event_handle[k]);
	}

	/* Get references to channel streams */
	ret = open_streams(sock, channel_data.handle,
			stream_data, MAX_NR_STREAMS);
	if (ret) {
		printf("Error in open_streams\n");
		return ret;
	}

	memset(&lum, 0, sizeof(lum));
	lum.handle = session_handle;
	lum.cmd = LTTNG_UST_SESSION_START;
	ret = send_app_cmd(sock, &lum, &lur);
	if (ret)
		return ret;
	printf("Session handle %u started.\n", session_handle);

	/* Tell application registration is done */
	memset(&lum, 0, sizeof(lum));
	lum.handle = LTTNG_UST_ROOT_HANDLE;
	lum.cmd = LTTNG_UST_REGISTER_DONE;
	ret = send_app_cmd(sock, &lum, &lur);
	if (ret)
		return ret;
	printf("Registration done acknowledged.\n");

	sleep(4);

	ret = consume_buffers(outputpath);
	if (ret) {
		printf("Error in consume_buffers\n");
		return ret;
	}

	/* Release data channel */
	/* Release streams */
	ret = close_streams(sock, stream_data,
			MAX_NR_STREAMS);
	if (ret)
		return ret;

	/* Release events */
	for (k = 0; k < nr_events; k++) {
		memset(&lum, 0, sizeof(lum));
		lum.handle = event_handle[k];
		lum.cmd = LTTNG_UST_RELEASE;
		ret = send_app_cmd(sock, &lum, &lur);
		if (ret)
			return ret;
	}
	memset(&lum, 0, sizeof(lum));
	lum.handle = channel_data.handle;
	lum.cmd = LTTNG_UST_RELEASE;
	ret = send_app_cmd(sock, &lum, &lur);
	if (ret)
		return ret;
	if (channel_data.shm_fd >= 0) {
		ret = close(channel_data.shm_fd);
		if (ret)
			return ret;
	}
	if (channel_data.wait_fd >= 0) {
		ret = close(channel_data.wait_fd);
		if (ret)
			return ret;
	}

	/* Release metadata channel */
	ret = close_streams(sock, &metadata_stream_data, 1);
	if (ret)
		return ret;

	memset(&lum, 0, sizeof(lum));
	lum.handle = metadata_data.handle;
	lum.cmd = LTTNG_UST_RELEASE;
	ret = send_app_cmd(sock, &lum, &lur);
	if (ret)
		return ret;
	if (metadata_data.shm_fd >= 0) {
		ret = close(metadata_data.shm_fd);
		if (ret)
			return ret;
	}
	if (metadata_data.wait_fd >= 0) {
		ret = close(metadata_data.wait_fd);
		if (ret)
			return ret;
	}

	/* Release session */
	memset(&lum, 0, sizeof(lum));
	lum.handle = session_handle;
	lum.cmd = LTTNG_UST_RELEASE;
	ret = send_app_cmd(sock, &lum, &lur);
	if (ret)
		return ret;

	return 0;
}

/*
 * Using fork to set umask in the child process (not multi-thread safe). We
 * deal with the shm_open vs ftruncate race (happening when the sessiond owns
 * the shm and does not let everybody modify it, to ensure safety against
 * shm_unlink) by simply letting the mmap fail and retrying after a few
 * seconds. For global shm, everybody has rw access to it until the sessiond
 * starts.
 */
static int get_wait_shm(char *shm_path, size_t mmap_size, int global)
{
	int wait_shm_fd, ret;
	mode_t mode;

	/* Default permissions */
	mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;

	/* Change owner of the shm path */
	if (global) {
		ret = chown(shm_path, 0, 0);
		if (ret < 0) {
			if (errno != ENOENT) {
				perror("chown wait shm");
				goto error;
			}
		}

		/*
		 * If global session daemon, any application can register so the shm
		 * needs to be set in read-only mode for others.
		 */
		mode |= S_IROTH;
	} else {
		ret = chown(shm_path, getuid(), getgid());
		if (ret < 0) {
			if (errno != ENOENT) {
				perror("chown wait shm");
				goto error;
			}
		}
	}

	/*
	 * Set permissions to the shm even if we did not create the shm.
	 */
	ret = chmod(shm_path, mode);
	if (ret < 0) {
		if (errno != ENOENT) {
			perror("chmod wait shm");
			goto error;
		}
	}

	/*
	 * We're alone in a child process, so we can modify the process-wide
	 * umask.
	 */
	umask(~mode);

	/*
	 * Try creating shm (or get rw access). We don't do an exclusive open,
	 * because we allow other processes to create+ftruncate it concurrently.
	 */
	wait_shm_fd = shm_open(shm_path, O_RDWR | O_CREAT, mode);
	if (wait_shm_fd < 0) {
		perror("shm_open wait shm");
		goto error;
	}

	ret = ftruncate(wait_shm_fd, mmap_size);
	if (ret < 0) {
		perror("ftruncate wait shm");
		exit(EXIT_FAILURE);
	}

	ret = fchmod(wait_shm_fd, mode);
	if (ret < 0) {
		perror("fchmod");
		exit(EXIT_FAILURE);
	}

	printf("Got the wait shm fd %d\n", wait_shm_fd);

	return wait_shm_fd;

error:
	printf("Failing to get the wait shm fd\n");

	return -1;
}

int update_futex(int fd, int active)
{
	size_t mmap_size = sysconf(_SC_PAGE_SIZE);
	char *wait_shm_mmap;
	int ret;

	wait_shm_mmap = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE,
		  MAP_SHARED, fd, 0);
	if (wait_shm_mmap == MAP_FAILED) {
		perror("mmap");
		goto error;
	}

	if (active) {
		uatomic_set((int32_t *) wait_shm_mmap, 1);
		futex_async((int32_t *) wait_shm_mmap, FUTEX_WAKE,
				INT_MAX, NULL, NULL, 0);
	} else {
		uatomic_set((int32_t *) wait_shm_mmap, 0);
	}
	ret = munmap(wait_shm_mmap, mmap_size);
	if (ret) {
		perror("Error unmapping wait shm");
		goto error;
	}
	return 0;
error:
	return -1;
}

/*
 * Set open files limit to unlimited. This daemon can open a large number of
 * file descriptors in order to consumer multiple kernel traces.
 */
static void set_ulimit(void)
{
	int ret;
	struct rlimit lim;

	/*
	 * If not root, we cannot increase our max open files. But our
	 * scope is then limited to processes from a single user.
	 */
	if (getuid() != 0)
		return;
	/* The kernel does not allowed an infinite limit for open files */
	lim.rlim_cur = 65535;
	lim.rlim_max = 65535;

	ret = setrlimit(RLIMIT_NOFILE, &lim);
	if (ret < 0) {
		perror("failed to set open files limit");
	}
}

/*
 * Usage:
 * ./ust-basic-tracing outputpath event_name1 event_name2 ....
 */
int main(int argc, const char **argv)
{
	const char *home_dir;
	int ret, wait_shm_fd;
	struct sigaction act;
	mode_t old_umask;
	const char *outputpath;
	const char **event_names;
	unsigned int nr_events;

	if (argc < 2) {
		printf("Usage:\n");
		printf("%s outputpath event_name1 event_name2 ...\n",
			argv[0]);
		exit(-1);
	}
	outputpath = argv[1];
	event_names = &argv[2];
	nr_events = argc - 2;

	set_ulimit();

	/* Ignore sigpipe */
	memset(&act, 0, sizeof(act));
	ret = sigemptyset(&act.sa_mask);
	if (ret == -1) {
		perror("sigemptyset");
		return -1;
	}

	act.sa_handler = SIG_IGN;
	ret = sigaction(SIGPIPE, &act, NULL);
	if (ret == -1) {
		perror("sigaction");
		return -1;
	}

	/* Handle SIGTERM */
	act.sa_handler = handle_signals;
	ret = sigaction(SIGTERM, &act, NULL);
	if (ret == -1) {
		perror("sigaction");
		return -1;
	}
	/* Handle SIGINT */
	ret = sigaction(SIGINT, &act, NULL);
	if (ret == -1) {
		perror("sigaction");
		return -1;
	}

	if (geteuid() == 0) {
		ret = mkdir(LTTNG_RUNDIR, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
		if (ret && errno != EEXIST) {
			perror("mkdir");
			return -1;
		}
		wait_shm_fd = get_wait_shm(DEFAULT_GLOBAL_APPS_WAIT_SHM_PATH,
					sysconf(_SC_PAGE_SIZE), 1);
		if (wait_shm_fd < 0) {
			perror("global wait shm error");
			return -1;
		}
		strcpy(apps_sock_path, DEFAULT_GLOBAL_APPS_UNIX_SOCK);
		old_umask = umask(0);
	} else {
		snprintf(local_apps_wait_shm_path, PATH_MAX,
			 DEFAULT_HOME_APPS_WAIT_SHM_PATH, getuid());
		wait_shm_fd = get_wait_shm(local_apps_wait_shm_path,
					sysconf(_SC_PAGE_SIZE), 0);
		if (wait_shm_fd < 0) {
			perror("local wait shm error");
			return -1;
		}
		home_dir = (const char *) getenv("HOME");
		if (!home_dir) {
			perror("getenv error");
			return -ENOENT;
		}
		snprintf(apps_sock_path, PATH_MAX,
			 DEFAULT_HOME_APPS_UNIX_SOCK, home_dir);
	}

	ret = lttcomm_create_unix_sock(apps_sock_path);
	if (ret < 0) {
		perror("create error");
		return ret;
	}
	apps_socket = ret;

	if (getuid() == 0) {
		/* File permission MUST be 666 */
		ret = chmod(apps_sock_path,
				S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
		if (ret < 0) {
			printf("Set file permissions failed: %s\n", apps_sock_path);
			perror("chmod");
			goto end;
		}
		umask(old_umask);
	}
	ret = lttcomm_listen_unix_sock(apps_socket);
	if (ret < 0) {
		perror("listen error");
		return ret;
	}

	/* wake up futexes */
	ret = update_futex(wait_shm_fd, 1);
	if (ret) {
		fprintf(stderr, "Error wakeup futex\n");
		return -1;
	}

	for (;;) {
		int sock;
		ssize_t len;
		struct {
			uint32_t major;
			uint32_t minor;
			pid_t pid;
			pid_t ppid;
			uid_t uid;
			gid_t gid;
			char name[16];	/* Process name */
		} reg_msg;
		char bufname[17];

		if (quit_program)
			break;

		printf("Accepting application registration\n");
		sock = lttcomm_accept_unix_sock(apps_socket);
		if (sock < 0) {
			perror("accept error");
			goto end;
		}

		/*
		 * Basic recv here to handle the very simple data
		 * that the libust send to register (reg_msg).
		 */
		len = lttcomm_recv_unix_sock(sock, &reg_msg, sizeof(reg_msg));
		if (len < 0 || len != sizeof(reg_msg)) {
			perror("lttcomm_recv_unix_sock");
			continue;
		}
		memcpy(bufname, reg_msg.name, 16);
		bufname[16] = '\0';
		printf("Application %s pid %u ppid %u uid %u gid %u has registered (version : %u.%u)\n",
			bufname, reg_msg.pid, reg_msg.ppid, reg_msg.uid,
			reg_msg.gid, reg_msg.major, reg_msg.minor);
		ret = send_app_msgs(sock, outputpath, nr_events, event_names);
		if (ret) {
			printf("Error in send_app_msgs.\n");
			sleep(1);
		}
		close(sock);
	}

end:
	printf("quitting.\n");
	/* Let applications know we are not responding anymore */
	ret = update_futex(wait_shm_fd, 0);
	if (ret) {
		fprintf(stderr, "Error wakeup futex\n");
		return -1;
	}

	return 0;
}