[lttng-ust.git] / liblttng-ust-ctl / ustctl.c

/*
 * Copyright (C) 2011 - Julien Desfossez <julien.desfossez@polymtl.ca>
 *                      Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * 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.
 */

#include <string.h>
#include <lttng/ust-ctl.h>
#include <lttng/ust-abi.h>
#include <lttng/usterr-signal-safe.h>
#include <lttng/ust-comm.h>

#include "../libringbuffer/backend.h"
#include "../libringbuffer/frontend.h"

volatile enum ust_loglevel ust_loglevel;

static
void init_object(struct lttng_ust_object_data *data)
{
	data->handle = -1;
	data->shm_fd = -1;
	data->wait_fd = -1;
	data->memory_map_size = 0;
}

void ustctl_release_object(int sock, struct lttng_ust_object_data *data)
{
	struct ustcomm_ust_msg lum;
	struct ustcomm_ust_reply lur;
	int ret;

	if (data->shm_fd >= 0)
		close(data->shm_fd);
	if (data->wait_fd >= 0)
		close(data->wait_fd);
	memset(&lum, 0, sizeof(lum));
	lum.handle = data->handle;
	lum.cmd = LTTNG_UST_RELEASE;
	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	assert(!ret);
	free(data);
}

/*
 * Send registration done packet to the application.
 */
int ustctl_register_done(int sock)
{
	struct ustcomm_ust_msg lum;
	struct ustcomm_ust_reply lur;
	int ret;

	DBG("Sending register done command to %d", sock);
	memset(&lum, 0, sizeof(lum));
	lum.handle = LTTNG_UST_ROOT_HANDLE;
	lum.cmd = LTTNG_UST_REGISTER_DONE;
	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	if (ret)
		return ret;
	if (lur.ret_code != USTCOMM_OK) {
		DBG("Return code: %s", ustcomm_get_readable_code(lur.ret_code));
		goto error;
	}
	return 0;

error:
	return -1;
}

/*
 * returns session handle.
 */
int ustctl_create_session(int sock)
{
	struct ustcomm_ust_msg lum;
	struct ustcomm_ust_reply lur;
	int ret, session_handle;

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

/* open the metadata global channel */
int ustctl_open_metadata(int sock, int session_handle,
		struct lttng_ust_channel_attr *chops,
		struct lttng_ust_object_data **_metadata_data)
{
	struct ustcomm_ust_msg lum;
	struct ustcomm_ust_reply lur;
	struct lttng_ust_object_data *metadata_data;
	int ret;

	metadata_data = malloc(sizeof(*metadata_data));
	if (!metadata_data)
		return -ENOMEM;
	init_object(metadata_data);
	/* Create metadata channel */
	memset(&lum, 0, sizeof(lum));
	lum.handle = session_handle;
	lum.cmd = LTTNG_UST_METADATA;
	lum.u.channel.overwrite = chops->overwrite;
	lum.u.channel.subbuf_size = chops->subbuf_size;
	lum.u.channel.num_subbuf = chops->num_subbuf;
	lum.u.channel.switch_timer_interval = chops->switch_timer_interval;
	lum.u.channel.read_timer_interval = chops->read_timer_interval;
	lum.u.channel.output = chops->output;
	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	if (ret) {
		free(metadata_data);
		return ret;
	}
	if (lur.ret_code != USTCOMM_OK) {
		free(metadata_data);
		return lur.ret_code;
	}
	metadata_data->handle = lur.ret_val;
	DBG("received metadata handle %u", metadata_data->handle);
	metadata_data->memory_map_size = lur.u.channel.memory_map_size;
	/* get shm fd */
	ret = ustcomm_recv_fd(sock);
	if (ret < 0)
		goto error;
	metadata_data->shm_fd = ret;
	/* get wait fd */
	ret = ustcomm_recv_fd(sock);
	if (ret < 0)
		goto error;
	metadata_data->wait_fd = ret;
	*_metadata_data = metadata_data;
	return 0;

error:
	ustctl_release_object(sock, metadata_data);
	return -EINVAL;
}

int ustctl_create_channel(int sock, int session_handle,
		struct lttng_ust_channel_attr *chops,
		struct lttng_ust_object_data **_channel_data)
{
	struct ustcomm_ust_msg lum;
	struct ustcomm_ust_reply lur;
	struct lttng_ust_object_data *channel_data;
	int ret;

	channel_data = malloc(sizeof(*channel_data));
	if (!channel_data)
		return -ENOMEM;
	init_object(channel_data);
	/* Create metadata channel */
	memset(&lum, 0, sizeof(lum));
	lum.handle = session_handle;
	lum.cmd = LTTNG_UST_CHANNEL;
	lum.u.channel.overwrite = chops->overwrite;
	lum.u.channel.subbuf_size = chops->subbuf_size;
	lum.u.channel.num_subbuf = chops->num_subbuf;
	lum.u.channel.switch_timer_interval = chops->switch_timer_interval;
	lum.u.channel.read_timer_interval = chops->read_timer_interval;
	lum.u.channel.output = chops->output;
	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	if (ret) {
		free(channel_data);
		return ret;
	}
	if (lur.ret_code != USTCOMM_OK) {
		free(channel_data);
		return lur.ret_code;
	}
	channel_data->handle = lur.ret_val;
	DBG("received channel handle %u", channel_data->handle);
	channel_data->memory_map_size = lur.u.channel.memory_map_size;
	/* get shm fd */
	ret = ustcomm_recv_fd(sock);
	if (ret < 0)
		goto error;
	channel_data->shm_fd = ret;
	/* get wait fd */
	ret = ustcomm_recv_fd(sock);
	if (ret < 0)
		goto error;
	channel_data->wait_fd = ret;
	*_channel_data = channel_data;
	return 0;

error:
	ustctl_release_object(sock, channel_data);
	return -EINVAL;
}

/*
 * Return -ENOENT if no more stream is available for creation.
 * Return 0 on success.
 * Return negative error value on error.
 */
int ustctl_create_stream(int sock, struct lttng_ust_object_data *channel_data,
		struct lttng_ust_object_data **_stream_data)
{
	struct ustcomm_ust_msg lum;
	struct ustcomm_ust_reply lur;
	struct lttng_ust_object_data *stream_data;
	int ret, fd;

	stream_data = malloc(sizeof(*stream_data));
	if (!stream_data)
		return -ENOMEM;
	init_object(stream_data);
	memset(&lum, 0, sizeof(lum));
	lum.handle = channel_data->handle;
	lum.cmd = LTTNG_UST_STREAM;
	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	if (ret) {
		free(stream_data);
		return ret;
	}
	if (lur.ret_code != USTCOMM_OK) {
		free(stream_data);
		return lur.ret_code;
	}

	stream_data->handle = lur.ret_val;
	DBG("received stream handle %u", stream_data->handle);
	stream_data->memory_map_size = lur.u.stream.memory_map_size;
	/* get shm fd */
	fd = ustcomm_recv_fd(sock);
	if (fd < 0)
		goto error;
	stream_data->shm_fd = fd;
	/* get wait fd */
	fd = ustcomm_recv_fd(sock);
	if (fd < 0)
		goto error;
	stream_data->wait_fd = fd;
	*_stream_data = stream_data;
	return ret;

error:
	ustctl_release_object(sock, stream_data);
	return -EINVAL;
}

int ustctl_create_event(int sock, struct lttng_ust_event *ev,
		struct lttng_ust_object_data *channel_data,
		struct lttng_ust_object_data **_event_data)
{
	struct ustcomm_ust_msg lum;
	struct ustcomm_ust_reply lur;
	struct lttng_ust_object_data *event_data;
	int ret;

	event_data = malloc(sizeof(*event_data));
	if (!event_data)
		return -ENOMEM;
	init_object(event_data);
	memset(&lum, 0, sizeof(lum));
	lum.handle = channel_data->handle;
	lum.cmd = LTTNG_UST_EVENT;
	strncpy(lum.u.event.name, ev->name,
		LTTNG_UST_SYM_NAME_LEN);
	lum.u.event.instrumentation = ev->instrumentation;
	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	if (ret) {
		free(event_data);
		return ret;
	}
	event_data->handle = lur.ret_val;
	DBG("received event handle %u", event_data->handle);
	*_event_data = event_data;
	return 0;
}

int ustctl_add_context(int sock, struct lttng_ust_context *ctx,
		struct lttng_ust_object_data *obj_data,
		struct lttng_ust_object_data **_context_data)
{
	struct ustcomm_ust_msg lum;
	struct ustcomm_ust_reply lur;
	struct lttng_ust_object_data *context_data;
	int ret;

	context_data = malloc(sizeof(*context_data));
	if (!context_data)
		return -ENOMEM;
	init_object(context_data);
	memset(&lum, 0, sizeof(lum));
	lum.handle = obj_data->handle;
	lum.cmd = LTTNG_UST_CONTEXT;
	lum.u.context.ctx = ctx->ctx;
	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	if (ret) {
		free(context_data);
		return ret;
	}
	context_data->handle = lur.ret_val;
	DBG("received context handle %u", context_data->handle);
	*_context_data = context_data;
	return ret;
}

/* Enable event, channel and session ioctl */
int ustctl_enable(int sock, struct lttng_ust_object_data *object)
{
	struct ustcomm_ust_msg lum;
	struct ustcomm_ust_reply lur;
	int ret;

	memset(&lum, 0, sizeof(lum));
	lum.handle = object->handle;
	lum.cmd = LTTNG_UST_ENABLE;
	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	if (ret)
		return ret;
	DBG("enabled handle %u", object->handle);
	return 0;
}

/* Disable event, channel and session ioctl */
int ustctl_disable(int sock, struct lttng_ust_object_data *object)
{
	struct ustcomm_ust_msg lum;
	struct ustcomm_ust_reply lur;
	int ret;

	memset(&lum, 0, sizeof(lum));
	lum.handle = object->handle;
	lum.cmd = LTTNG_UST_DISABLE;
	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	if (ret)
		return ret;
	DBG("disable handle %u", object->handle);
	return 0;
}

int ustctl_start_session(int sock, int handle)
{
	struct lttng_ust_object_data obj;

	obj.handle = handle;
	return ustctl_enable(sock, &obj);
}

int ustctl_stop_session(int sock, int handle)
{
	struct lttng_ust_object_data obj;

	obj.handle = handle;
	return ustctl_disable(sock, &obj);
}


int ustctl_tracepoint_list(int sock)
{
	return -ENOSYS;	/* not implemented */
}

int ustctl_tracer_version(int sock, struct lttng_ust_tracer_version *v)
{
	struct ustcomm_ust_msg lum;
	struct ustcomm_ust_reply lur;
	int ret;

	memset(&lum, 0, sizeof(lum));
	lum.handle = LTTNG_UST_ROOT_HANDLE;
	lum.cmd = LTTNG_UST_TRACER_VERSION;
	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	if (ret)
		return ret;
	memcpy(v, &lur.u.version, sizeof(*v));
	DBG("received tracer version");
	return 0;
}

int ustctl_wait_quiescent(int sock)
{
	struct ustcomm_ust_msg lum;
	struct ustcomm_ust_reply lur;
	int ret;

	memset(&lum, 0, sizeof(lum));
	lum.handle = LTTNG_UST_ROOT_HANDLE;
	lum.cmd = LTTNG_UST_WAIT_QUIESCENT;
	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	if (ret)
		return ret;
	DBG("waited for quiescent state");
	return 0;
}

int ustctl_calibrate(int sock, struct lttng_ust_calibrate *calibrate)
{
	return -ENOSYS;
}

/* Buffer operations */

/* Map channel shm into process memory */
struct lttng_ust_shm_handle *ustctl_map_channel(struct lttng_ust_object_data *chan_data)
{
	struct lttng_ust_shm_handle *handle;
	struct channel *chan;
	size_t chan_size;

	handle = channel_handle_create(chan_data->shm_fd,
		chan_data->wait_fd,
		chan_data->memory_map_size);
	if (!handle) {
		ERR("create handle error");
		return NULL;
	}
	/*
	 * Set to -1 because the lttng_ust_shm_handle destruction will take care
	 * of closing shm_fd and wait_fd.
	 */
	chan_data->shm_fd = -1;
	chan_data->wait_fd = -1;

	/*
	 * TODO: add consistency checks to be resilient if the
	 * application try to feed us with incoherent channel structure
	 * values.
	 */
	chan = shmp(handle, handle->chan);
	/* chan is object 0. This is hardcoded. */
	chan_size = handle->table->objects[0].allocated_len;
	handle->shadow_chan = malloc(chan_size);
	if (!handle->shadow_chan) {
		channel_destroy(chan, handle, 1);
		return NULL;
	}
	memcpy(handle->shadow_chan, chan, chan_size);
	return handle;
}

/* Add stream to channel shm and map its shm into process memory */
int ustctl_add_stream(struct lttng_ust_shm_handle *handle,
		struct lttng_ust_object_data *stream_data)
{
	int ret;

	if (!stream_data->handle)
		return -ENOENT;
	/* map stream */
	ret = channel_handle_add_stream(handle,
		stream_data->shm_fd,
		stream_data->wait_fd,
		stream_data->memory_map_size);
	if (ret) {
		ERR("add stream error\n");
		return ret;
	}
	/*
	 * Set to -1 because the lttng_ust_shm_handle destruction will take care
	 * of closing shm_fd and wait_fd.
	 */
	stream_data->shm_fd = -1;
	stream_data->wait_fd = -1;
	return 0;
}

void ustctl_unmap_channel(struct lttng_ust_shm_handle *handle)
{
	struct channel *chan;

	chan = shmp(handle, handle->chan);
	channel_destroy(chan, handle, 1);
}

struct lttng_ust_lib_ring_buffer *ustctl_open_stream_read(struct lttng_ust_shm_handle *handle,
	int cpu)
{
	struct channel *chan = handle->shadow_chan;
	int shm_fd, wait_fd;
	uint64_t memory_map_size;
	struct lttng_ust_lib_ring_buffer *buf;
	int ret;

	buf = channel_get_ring_buffer(&chan->backend.config,
		chan, cpu, handle, &shm_fd, &wait_fd, &memory_map_size);
	if (!buf)
		return NULL;
	ret = lib_ring_buffer_open_read(buf, handle, 1);
	if (ret)
		return NULL;
	return buf;
}

void ustctl_close_stream_read(struct lttng_ust_shm_handle *handle,
		struct lttng_ust_lib_ring_buffer *buf)
{
	lib_ring_buffer_release_read(buf, handle, 1);
}

/* For mmap mode, readable without "get" operation */

void *ustctl_get_mmap_base(struct lttng_ust_shm_handle *handle,
		struct lttng_ust_lib_ring_buffer *buf)
{
	return shmp(handle, buf->backend.memory_map);
}

/* returns the length to mmap. */
int ustctl_get_mmap_len(struct lttng_ust_shm_handle *handle,
		struct lttng_ust_lib_ring_buffer *buf,
		unsigned long *len)
{
	unsigned long mmap_buf_len;
	struct channel *chan = handle->shadow_chan;

	if (chan->backend.config.output != RING_BUFFER_MMAP)
		return -EINVAL;
	mmap_buf_len = chan->backend.buf_size;
	if (chan->backend.extra_reader_sb)
		mmap_buf_len += chan->backend.subbuf_size;
	if (mmap_buf_len > INT_MAX)
		return -EFBIG;
	*len = mmap_buf_len;
	return 0;
}

/* returns the maximum size for sub-buffers. */
int ustctl_get_max_subbuf_size(struct lttng_ust_shm_handle *handle,
		struct lttng_ust_lib_ring_buffer *buf,
		unsigned long *len)
{
	struct channel *chan = handle->shadow_chan;

	*len = chan->backend.subbuf_size;
	return 0;
}

/*
 * For mmap mode, operate on the current packet (between get/put or
 * get_next/put_next).
 */

/* returns the offset of the subbuffer belonging to the mmap reader. */
int ustctl_get_mmap_read_offset(struct lttng_ust_shm_handle *handle,
		struct lttng_ust_lib_ring_buffer *buf, unsigned long *off)
{
	struct channel *chan = handle->shadow_chan;
	unsigned long sb_bindex;

	if (chan->backend.config.output != RING_BUFFER_MMAP)
		return -EINVAL;
	sb_bindex = subbuffer_id_get_index(&chan->backend.config,
					   buf->backend.buf_rsb.id);
	*off = shmp(handle, shmp_index(handle, buf->backend.array, sb_bindex)->shmp)->mmap_offset;
	return 0;
}

/* returns the size of the current sub-buffer, without padding (for mmap). */
int ustctl_get_subbuf_size(struct lttng_ust_shm_handle *handle,
		struct lttng_ust_lib_ring_buffer *buf, unsigned long *len)
{
	struct channel *chan = handle->shadow_chan;

	*len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf,
		handle);
	return 0;
}

/* returns the size of the current sub-buffer, without padding (for mmap). */
int ustctl_get_padded_subbuf_size(struct lttng_ust_shm_handle *handle,
		struct lttng_ust_lib_ring_buffer *buf, unsigned long *len)
{
	struct channel *chan = handle->shadow_chan;

	*len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf,
		handle);
	*len = PAGE_ALIGN(*len);
	return 0;
}

/* Get exclusive read access to the next sub-buffer that can be read. */
int ustctl_get_next_subbuf(struct lttng_ust_shm_handle *handle,
		struct lttng_ust_lib_ring_buffer *buf)
{
	return lib_ring_buffer_get_next_subbuf(buf, handle);
}


/* Release exclusive sub-buffer access, move consumer forward. */
int ustctl_put_next_subbuf(struct lttng_ust_shm_handle *handle,
		struct lttng_ust_lib_ring_buffer *buf)
{
	lib_ring_buffer_put_next_subbuf(buf, handle);
	return 0;
}

/* snapshot */

/* Get a snapshot of the current ring buffer producer and consumer positions */
int ustctl_snapshot(struct lttng_ust_shm_handle *handle,
		struct lttng_ust_lib_ring_buffer *buf)
{
	return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
			&buf->prod_snapshot, handle);
}

/* Get the consumer position (iteration start) */
int ustctl_snapshot_get_consumed(struct lttng_ust_shm_handle *handle,
		struct lttng_ust_lib_ring_buffer *buf, unsigned long *pos)
{
	*pos = buf->cons_snapshot;
	return 0;
}

/* Get the producer position (iteration end) */
int ustctl_snapshot_get_produced(struct lttng_ust_shm_handle *handle,
		struct lttng_ust_lib_ring_buffer *buf, unsigned long *pos)
{
	*pos = buf->prod_snapshot;
	return 0;
}

/* Get exclusive read access to the specified sub-buffer position */
int ustctl_get_subbuf(struct lttng_ust_shm_handle *handle,
		struct lttng_ust_lib_ring_buffer *buf, unsigned long *pos)
{
	return lib_ring_buffer_get_subbuf(buf, *pos, handle);
}

/* Release exclusive sub-buffer access */
int ustctl_put_subbuf(struct lttng_ust_shm_handle *handle,
		struct lttng_ust_lib_ring_buffer *buf)
{
	lib_ring_buffer_put_subbuf(buf, handle);
	return 0;
}

int ustctl_flush_buffer(struct lttng_ust_shm_handle *handle,
		struct lttng_ust_lib_ring_buffer *buf)
{
	lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE, handle);
	return 0;
}
Commit	Line	Data
57773204 MD	1	/*
	2	* Copyright (C) 2011 - Julien Desfossez <julien.desfossez@polymtl.ca>
	3	* Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	4	*
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU General Public License
	7	* as published by the Free Software Foundation; only version 2
	8	* of the License.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	18	*/
	19
	20	#include <string.h>
4318ae1b MD	21	#include <lttng/ust-ctl.h>
	22	#include <lttng/ust-abi.h>
	23	#include <lttng/usterr-signal-safe.h>
	24	#include <lttng/ust-comm.h>
57773204 MD	25
	26	#include "../libringbuffer/backend.h"
	27	#include "../libringbuffer/frontend.h"
	28
6b120308 MD	29	volatile enum ust_loglevel ust_loglevel;
6b120308 MD	30
57773204	31	static
61f02aea	32	void init_object(struct lttng_ust_object_data *data)
57773204 MD	33	{
	34	data->handle = -1;
	35	data->shm_fd = -1;
	36	data->wait_fd = -1;
	37	data->memory_map_size = 0;
	38	}
	39
5f9d3dbc	40	void ustctl_release_object(int sock, struct lttng_ust_object_data *data)
57773204 MD	41	{
	42	struct ustcomm_ust_msg lum;
	43	struct ustcomm_ust_reply lur;
	44	int ret;
	45
	46	if (data->shm_fd >= 0)
	47	close(data->shm_fd);
	48	if (data->wait_fd >= 0)
	49	close(data->wait_fd);
	50	memset(&lum, 0, sizeof(lum));
	51	lum.handle = data->handle;
	52	lum.cmd = LTTNG_UST_RELEASE;
	53	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	54	assert(!ret);
	55	free(data);
	56	}
	57
1c5e467e MD	58	/*
	59	* Send registration done packet to the application.
	60	*/
	61	int ustctl_register_done(int sock)
	62	{
	63	struct ustcomm_ust_msg lum;
	64	struct ustcomm_ust_reply lur;
	65	int ret;
	66
	67	DBG("Sending register done command to %d", sock);
	68	memset(&lum, 0, sizeof(lum));
	69	lum.handle = LTTNG_UST_ROOT_HANDLE;
	70	lum.cmd = LTTNG_UST_REGISTER_DONE;
	71	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	72	if (ret)
	73	return ret;
	74	if (lur.ret_code != USTCOMM_OK) {
	75	DBG("Return code: %s", ustcomm_get_readable_code(lur.ret_code));
	76	goto error;
	77	}
	78	return 0;
	79
	80	error:
	81	return -1;
	82	}
	83
57773204 MD	84	/*
	85	* returns session handle.
	86	*/
	87	int ustctl_create_session(int sock)
	88	{
	89	struct ustcomm_ust_msg lum;
	90	struct ustcomm_ust_reply lur;
	91	int ret, session_handle;
	92
	93	/* Create session */
	94	memset(&lum, 0, sizeof(lum));
	95	lum.handle = LTTNG_UST_ROOT_HANDLE;
	96	lum.cmd = LTTNG_UST_SESSION;
	97	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	98	if (ret)
	99	return ret;
	100	session_handle = lur.ret_val;
	101	DBG("received session handle %u", session_handle);
	102	return session_handle;
	103	}
	104
	105	/* open the metadata global channel */
	106	int ustctl_open_metadata(int sock, int session_handle,
	107	struct lttng_ust_channel_attr *chops,
61f02aea	108	struct lttng_ust_object_data **_metadata_data)
57773204 MD	109	{
	110	struct ustcomm_ust_msg lum;
	111	struct ustcomm_ust_reply lur;
61f02aea	112	struct lttng_ust_object_data *metadata_data;
57773204 MD	113	int ret;
	114
	115	metadata_data = malloc(sizeof(*metadata_data));
	116	if (!metadata_data)
	117	return -ENOMEM;
	118	init_object(metadata_data);
	119	/* Create metadata channel */
	120	memset(&lum, 0, sizeof(lum));
	121	lum.handle = session_handle;
	122	lum.cmd = LTTNG_UST_METADATA;
	123	lum.u.channel.overwrite = chops->overwrite;
	124	lum.u.channel.subbuf_size = chops->subbuf_size;
	125	lum.u.channel.num_subbuf = chops->num_subbuf;
	126	lum.u.channel.switch_timer_interval = chops->switch_timer_interval;
	127	lum.u.channel.read_timer_interval = chops->read_timer_interval;
	128	lum.u.channel.output = chops->output;
	129	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	130	if (ret) {
	131	free(metadata_data);
	132	return ret;
	133	}
	134	if (lur.ret_code != USTCOMM_OK) {
	135	free(metadata_data);
	136	return lur.ret_code;
	137	}
	138	metadata_data->handle = lur.ret_val;
	139	DBG("received metadata handle %u", metadata_data->handle);
	140	metadata_data->memory_map_size = lur.u.channel.memory_map_size;
	141	/* get shm fd */
	142	ret = ustcomm_recv_fd(sock);
	143	if (ret < 0)
	144	goto error;
	145	metadata_data->shm_fd = ret;
	146	/* get wait fd */
	147	ret = ustcomm_recv_fd(sock);
	148	if (ret < 0)
	149	goto error;
	150	metadata_data->wait_fd = ret;
	151	*_metadata_data = metadata_data;
	152	return 0;
	153
	154	error:
5f9d3dbc	155	ustctl_release_object(sock, metadata_data);
57773204 MD	156	return -EINVAL;
	157	}
	158
	159	int ustctl_create_channel(int sock, int session_handle,
	160	struct lttng_ust_channel_attr *chops,
61f02aea	161	struct lttng_ust_object_data **_channel_data)
57773204 MD	162	{
	163	struct ustcomm_ust_msg lum;
	164	struct ustcomm_ust_reply lur;
61f02aea	165	struct lttng_ust_object_data *channel_data;
57773204 MD	166	int ret;
	167
	168	channel_data = malloc(sizeof(*channel_data));
	169	if (!channel_data)
	170	return -ENOMEM;
	171	init_object(channel_data);
	172	/* Create metadata channel */
	173	memset(&lum, 0, sizeof(lum));
	174	lum.handle = session_handle;
	175	lum.cmd = LTTNG_UST_CHANNEL;
	176	lum.u.channel.overwrite = chops->overwrite;
	177	lum.u.channel.subbuf_size = chops->subbuf_size;
	178	lum.u.channel.num_subbuf = chops->num_subbuf;
	179	lum.u.channel.switch_timer_interval = chops->switch_timer_interval;
	180	lum.u.channel.read_timer_interval = chops->read_timer_interval;
	181	lum.u.channel.output = chops->output;
	182	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	183	if (ret) {
	184	free(channel_data);
	185	return ret;
	186	}
	187	if (lur.ret_code != USTCOMM_OK) {
	188	free(channel_data);
	189	return lur.ret_code;
	190	}
	191	channel_data->handle = lur.ret_val;
	192	DBG("received channel handle %u", channel_data->handle);
	193	channel_data->memory_map_size = lur.u.channel.memory_map_size;
	194	/* get shm fd */
	195	ret = ustcomm_recv_fd(sock);
	196	if (ret < 0)
	197	goto error;
	198	channel_data->shm_fd = ret;
	199	/* get wait fd */
	200	ret = ustcomm_recv_fd(sock);
	201	if (ret < 0)
	202	goto error;
	203	channel_data->wait_fd = ret;
	204	*_channel_data = channel_data;
	205	return 0;
	206
	207	error:
5f9d3dbc	208	ustctl_release_object(sock, channel_data);
57773204 MD	209	return -EINVAL;
	210	}
	211
	212	/*
	213	* Return -ENOENT if no more stream is available for creation.
	214	* Return 0 on success.
	215	* Return negative error value on error.
	216	*/
61f02aea MD	217	int ustctl_create_stream(int sock, struct lttng_ust_object_data *channel_data,
61f02aea MD	218	struct lttng_ust_object_data **_stream_data)
57773204 MD	219	{
	220	struct ustcomm_ust_msg lum;
	221	struct ustcomm_ust_reply lur;
61f02aea	222	struct lttng_ust_object_data *stream_data;
57773204 MD	223	int ret, fd;
	224
	225	stream_data = malloc(sizeof(*stream_data));
	226	if (!stream_data)
	227	return -ENOMEM;
	228	init_object(stream_data);
	229	memset(&lum, 0, sizeof(lum));
	230	lum.handle = channel_data->handle;
	231	lum.cmd = LTTNG_UST_STREAM;
	232	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	233	if (ret) {
	234	free(stream_data);
	235	return ret;
	236	}
	237	if (lur.ret_code != USTCOMM_OK) {
	238	free(stream_data);
	239	return lur.ret_code;
	240	}
	241
	242	stream_data->handle = lur.ret_val;
	243	DBG("received stream handle %u", stream_data->handle);
	244	stream_data->memory_map_size = lur.u.stream.memory_map_size;
	245	/* get shm fd */
	246	fd = ustcomm_recv_fd(sock);
	247	if (fd < 0)
	248	goto error;
	249	stream_data->shm_fd = fd;
	250	/* get wait fd */
	251	fd = ustcomm_recv_fd(sock);
	252	if (fd < 0)
	253	goto error;
	254	stream_data->wait_fd = fd;
	255	*_stream_data = stream_data;
	256	return ret;
	257
	258	error:
5f9d3dbc	259	ustctl_release_object(sock, stream_data);
57773204 MD	260	return -EINVAL;
	261	}
	262
	263	int ustctl_create_event(int sock, struct lttng_ust_event *ev,
61f02aea MD	264	struct lttng_ust_object_data *channel_data,
61f02aea MD	265	struct lttng_ust_object_data **_event_data)
57773204 MD	266	{
	267	struct ustcomm_ust_msg lum;
	268	struct ustcomm_ust_reply lur;
61f02aea	269	struct lttng_ust_object_data *event_data;
57773204 MD	270	int ret;
	271
	272	event_data = malloc(sizeof(*event_data));
	273	if (!event_data)
	274	return -ENOMEM;
	275	init_object(event_data);
	276	memset(&lum, 0, sizeof(lum));
	277	lum.handle = channel_data->handle;
	278	lum.cmd = LTTNG_UST_EVENT;
	279	strncpy(lum.u.event.name, ev->name,
	280	LTTNG_UST_SYM_NAME_LEN);
	281	lum.u.event.instrumentation = ev->instrumentation;
	282	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	283	if (ret) {
	284	free(event_data);
	285	return ret;
	286	}
	287	event_data->handle = lur.ret_val;
	288	DBG("received event handle %u", event_data->handle);
	289	*_event_data = event_data;
	290	return 0;
	291	}
	292
	293	int ustctl_add_context(int sock, struct lttng_ust_context *ctx,
61f02aea MD	294	struct lttng_ust_object_data *obj_data,
61f02aea MD	295	struct lttng_ust_object_data **_context_data)
57773204 MD	296	{
	297	struct ustcomm_ust_msg lum;
	298	struct ustcomm_ust_reply lur;
61f02aea	299	struct lttng_ust_object_data *context_data;
57773204 MD	300	int ret;
	301
	302	context_data = malloc(sizeof(*context_data));
	303	if (!context_data)
	304	return -ENOMEM;
	305	init_object(context_data);
	306	memset(&lum, 0, sizeof(lum));
3039d8ed	307	lum.handle = obj_data->handle;
57773204 MD	308	lum.cmd = LTTNG_UST_CONTEXT;
	309	lum.u.context.ctx = ctx->ctx;
	310	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	311	if (ret) {
	312	free(context_data);
	313	return ret;
	314	}
	315	context_data->handle = lur.ret_val;
	316	DBG("received context handle %u", context_data->handle);
	317	*_context_data = context_data;
	318	return ret;
	319	}
	320
	321	/* Enable event, channel and session ioctl */
61f02aea	322	int ustctl_enable(int sock, struct lttng_ust_object_data *object)
57773204 MD	323	{
	324	struct ustcomm_ust_msg lum;
	325	struct ustcomm_ust_reply lur;
	326	int ret;
	327
	328	memset(&lum, 0, sizeof(lum));
	329	lum.handle = object->handle;
	330	lum.cmd = LTTNG_UST_ENABLE;
	331	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	332	if (ret)
	333	return ret;
	334	DBG("enabled handle %u", object->handle);
	335	return 0;
	336	}
	337
	338	/* Disable event, channel and session ioctl */
61f02aea	339	int ustctl_disable(int sock, struct lttng_ust_object_data *object)
57773204 MD	340	{
	341	struct ustcomm_ust_msg lum;
	342	struct ustcomm_ust_reply lur;
	343	int ret;
	344
	345	memset(&lum, 0, sizeof(lum));
	346	lum.handle = object->handle;
	347	lum.cmd = LTTNG_UST_DISABLE;
	348	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	349	if (ret)
	350	return ret;
	351	DBG("disable handle %u", object->handle);
	352	return 0;
	353	}
	354
4a6ca058	355	int ustctl_start_session(int sock, int handle)
57773204	356	{
61f02aea	357	struct lttng_ust_object_data obj;
4a6ca058 MD	358
	359	obj.handle = handle;
	360	return ustctl_enable(sock, &obj);
57773204 MD	361	}
57773204 MD	362
4a6ca058	363	int ustctl_stop_session(int sock, int handle)
57773204	364	{
61f02aea	365	struct lttng_ust_object_data obj;
4a6ca058 MD	366
	367	obj.handle = handle;
	368	return ustctl_disable(sock, &obj);
57773204 MD	369	}
	370
	371
	372	int ustctl_tracepoint_list(int sock)
	373	{
	374	return -ENOSYS; /* not implemented */
	375	}
	376
	377	int ustctl_tracer_version(int sock, struct lttng_ust_tracer_version *v)
	378	{
	379	struct ustcomm_ust_msg lum;
	380	struct ustcomm_ust_reply lur;
	381	int ret;
	382
	383	memset(&lum, 0, sizeof(lum));
	384	lum.handle = LTTNG_UST_ROOT_HANDLE;
	385	lum.cmd = LTTNG_UST_TRACER_VERSION;
	386	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	387	if (ret)
	388	return ret;
	389	memcpy(v, &lur.u.version, sizeof(*v));
	390	DBG("received tracer version");
	391	return 0;
	392	}
	393
	394	int ustctl_wait_quiescent(int sock)
	395	{
	396	struct ustcomm_ust_msg lum;
	397	struct ustcomm_ust_reply lur;
	398	int ret;
	399
	400	memset(&lum, 0, sizeof(lum));
	401	lum.handle = LTTNG_UST_ROOT_HANDLE;
	402	lum.cmd = LTTNG_UST_WAIT_QUIESCENT;
	403	ret = ustcomm_send_app_cmd(sock, &lum, &lur);
	404	if (ret)
	405	return ret;
	406	DBG("waited for quiescent state");
	407	return 0;
	408	}
	409
	410	int ustctl_calibrate(int sock, struct lttng_ust_calibrate *calibrate)
	411	{
	412	return -ENOSYS;
	413	}
	414
	415	/* Buffer operations */
	416
	417	/* Map channel shm into process memory */
38fae1d3	418	struct lttng_ust_shm_handle ustctl_map_channel(struct lttng_ust_object_data chan_data)
57773204	419	{
38fae1d3	420	struct lttng_ust_shm_handle *handle;
57773204 MD	421	struct channel *chan;
	422	size_t chan_size;
	423
	424	handle = channel_handle_create(chan_data->shm_fd,
	425	chan_data->wait_fd,
	426	chan_data->memory_map_size);
	427	if (!handle) {
	428	ERR("create handle error");
	429	return NULL;
	430	}
	431	/*
38fae1d3	432	* Set to -1 because the lttng_ust_shm_handle destruction will take care
57773204 MD	433	* of closing shm_fd and wait_fd.
	434	*/
	435	chan_data->shm_fd = -1;
	436	chan_data->wait_fd = -1;
	437
	438	/*
	439	* TODO: add consistency checks to be resilient if the
	440	* application try to feed us with incoherent channel structure
	441	* values.
	442	*/
	443	chan = shmp(handle, handle->chan);
	444	/* chan is object 0. This is hardcoded. */
	445	chan_size = handle->table->objects[0].allocated_len;
	446	handle->shadow_chan = malloc(chan_size);
	447	if (!handle->shadow_chan) {
	448	channel_destroy(chan, handle, 1);
	449	return NULL;
	450	}
	451	memcpy(handle->shadow_chan, chan, chan_size);
	452	return handle;
	453	}
	454
	455	/* Add stream to channel shm and map its shm into process memory */
38fae1d3	456	int ustctl_add_stream(struct lttng_ust_shm_handle *handle,
61f02aea	457	struct lttng_ust_object_data *stream_data)
57773204 MD	458	{
	459	int ret;
	460
	461	if (!stream_data->handle)
	462	return -ENOENT;
	463	/* map stream */
	464	ret = channel_handle_add_stream(handle,
	465	stream_data->shm_fd,
	466	stream_data->wait_fd,
	467	stream_data->memory_map_size);
	468	if (ret) {
	469	ERR("add stream error\n");
	470	return ret;
	471	}
	472	/*
38fae1d3	473	* Set to -1 because the lttng_ust_shm_handle destruction will take care
57773204 MD	474	* of closing shm_fd and wait_fd.
	475	*/
	476	stream_data->shm_fd = -1;
	477	stream_data->wait_fd = -1;
	478	return 0;
	479	}
	480
38fae1d3	481	void ustctl_unmap_channel(struct lttng_ust_shm_handle *handle)
5224b5c8 MD	482	{
	483	struct channel *chan;
	484
	485	chan = shmp(handle, handle->chan);
	486	channel_destroy(chan, handle, 1);
	487	}
	488
4cfec15c	489	struct lttng_ust_lib_ring_buffer ustctl_open_stream_read(struct lttng_ust_shm_handle handle,
6e922b24 MD	490	int cpu)
	491	{
	492	struct channel *chan = handle->shadow_chan;
	493	int shm_fd, wait_fd;
	494	uint64_t memory_map_size;
4cfec15c	495	struct lttng_ust_lib_ring_buffer *buf;
6e922b24 MD	496	int ret;
	497
	498	buf = channel_get_ring_buffer(&chan->backend.config,
	499	chan, cpu, handle, &shm_fd, &wait_fd, &memory_map_size);
	500	if (!buf)
	501	return NULL;
	502	ret = lib_ring_buffer_open_read(buf, handle, 1);
	503	if (ret)
	504	return NULL;
	505	return buf;
	506	}
	507
38fae1d3	508	void ustctl_close_stream_read(struct lttng_ust_shm_handle *handle,
4cfec15c	509	struct lttng_ust_lib_ring_buffer *buf)
6e922b24 MD	510	{
	511	lib_ring_buffer_release_read(buf, handle, 1);
	512	}
	513
57773204 MD	514	/* For mmap mode, readable without "get" operation */
57773204 MD	515
38fae1d3	516	void ustctl_get_mmap_base(struct lttng_ust_shm_handle handle,
4cfec15c	517	struct lttng_ust_lib_ring_buffer *buf)
9095efe9 MD	518	{
	519	return shmp(handle, buf->backend.memory_map);
	520	}
	521
57773204	522	/* returns the length to mmap. */
38fae1d3	523	int ustctl_get_mmap_len(struct lttng_ust_shm_handle *handle,
4cfec15c	524	struct lttng_ust_lib_ring_buffer *buf,
57773204 MD	525	unsigned long *len)
	526	{
	527	unsigned long mmap_buf_len;
	528	struct channel *chan = handle->shadow_chan;
	529
	530	if (chan->backend.config.output != RING_BUFFER_MMAP)
	531	return -EINVAL;
	532	mmap_buf_len = chan->backend.buf_size;
	533	if (chan->backend.extra_reader_sb)
	534	mmap_buf_len += chan->backend.subbuf_size;
	535	if (mmap_buf_len > INT_MAX)
	536	return -EFBIG;
	537	*len = mmap_buf_len;
	538	return 0;
	539	}
	540
	541	/* returns the maximum size for sub-buffers. */
38fae1d3	542	int ustctl_get_max_subbuf_size(struct lttng_ust_shm_handle *handle,
4cfec15c	543	struct lttng_ust_lib_ring_buffer *buf,
57773204 MD	544	unsigned long *len)
	545	{
	546	struct channel *chan = handle->shadow_chan;
	547
	548	*len = chan->backend.subbuf_size;
	549	return 0;
	550	}
	551
	552	/*
	553	* For mmap mode, operate on the current packet (between get/put or
	554	* get_next/put_next).
	555	*/
	556
	557	/* returns the offset of the subbuffer belonging to the mmap reader. */
38fae1d3	558	int ustctl_get_mmap_read_offset(struct lttng_ust_shm_handle *handle,
4cfec15c	559	struct lttng_ust_lib_ring_buffer buf, unsigned long off)
57773204 MD	560	{
	561	struct channel *chan = handle->shadow_chan;
	562	unsigned long sb_bindex;
	563
	564	if (chan->backend.config.output != RING_BUFFER_MMAP)
	565	return -EINVAL;
	566	sb_bindex = subbuffer_id_get_index(&chan->backend.config,
	567	buf->backend.buf_rsb.id);
	568	*off = shmp(handle, shmp_index(handle, buf->backend.array, sb_bindex)->shmp)->mmap_offset;
	569	return 0;
	570	}
	571
	572	/* returns the size of the current sub-buffer, without padding (for mmap). */
38fae1d3	573	int ustctl_get_subbuf_size(struct lttng_ust_shm_handle *handle,
4cfec15c	574	struct lttng_ust_lib_ring_buffer buf, unsigned long len)
57773204 MD	575	{
	576	struct channel *chan = handle->shadow_chan;
	577
	578	*len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf,
	579	handle);
	580	return 0;
	581	}
	582
	583	/* returns the size of the current sub-buffer, without padding (for mmap). */
38fae1d3	584	int ustctl_get_padded_subbuf_size(struct lttng_ust_shm_handle *handle,
4cfec15c	585	struct lttng_ust_lib_ring_buffer buf, unsigned long len)
57773204 MD	586	{
	587	struct channel *chan = handle->shadow_chan;
	588
	589	*len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf,
	590	handle);
	591	len = PAGE_ALIGN(len);
	592	return 0;
	593	}
	594
	595	/* Get exclusive read access to the next sub-buffer that can be read. */
38fae1d3	596	int ustctl_get_next_subbuf(struct lttng_ust_shm_handle *handle,
4cfec15c	597	struct lttng_ust_lib_ring_buffer *buf)
57773204 MD	598	{
	599	return lib_ring_buffer_get_next_subbuf(buf, handle);
	600	}
	601
	602
	603	/* Release exclusive sub-buffer access, move consumer forward. */
38fae1d3	604	int ustctl_put_next_subbuf(struct lttng_ust_shm_handle *handle,
4cfec15c	605	struct lttng_ust_lib_ring_buffer *buf)
57773204 MD	606	{
	607	lib_ring_buffer_put_next_subbuf(buf, handle);
	608	return 0;
	609	}
	610
	611	/* snapshot */
	612
	613	/* Get a snapshot of the current ring buffer producer and consumer positions */
38fae1d3	614	int ustctl_snapshot(struct lttng_ust_shm_handle *handle,
4cfec15c	615	struct lttng_ust_lib_ring_buffer *buf)
57773204 MD	616	{
	617	return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot,
	618	&buf->prod_snapshot, handle);
	619	}
	620
	621	/* Get the consumer position (iteration start) */
38fae1d3	622	int ustctl_snapshot_get_consumed(struct lttng_ust_shm_handle *handle,
4cfec15c	623	struct lttng_ust_lib_ring_buffer buf, unsigned long pos)
57773204 MD	624	{
	625	*pos = buf->cons_snapshot;
	626	return 0;
	627	}
	628
	629	/* Get the producer position (iteration end) */
38fae1d3	630	int ustctl_snapshot_get_produced(struct lttng_ust_shm_handle *handle,
4cfec15c	631	struct lttng_ust_lib_ring_buffer buf, unsigned long pos)
57773204 MD	632	{
	633	*pos = buf->prod_snapshot;
	634	return 0;
	635	}
	636
	637	/* Get exclusive read access to the specified sub-buffer position */
38fae1d3	638	int ustctl_get_subbuf(struct lttng_ust_shm_handle *handle,
4cfec15c	639	struct lttng_ust_lib_ring_buffer buf, unsigned long pos)
57773204 MD	640	{
	641	return lib_ring_buffer_get_subbuf(buf, *pos, handle);
	642	}
	643
	644	/* Release exclusive sub-buffer access */
38fae1d3	645	int ustctl_put_subbuf(struct lttng_ust_shm_handle *handle,
4cfec15c	646	struct lttng_ust_lib_ring_buffer *buf)
57773204 MD	647	{
	648	lib_ring_buffer_put_subbuf(buf, handle);
	649	return 0;
	650	}
	651
5f9d3dbc	652	int ustctl_flush_buffer(struct lttng_ust_shm_handle *handle,
4cfec15c	653	struct lttng_ust_lib_ring_buffer *buf)
57773204 MD	654	{
	655	lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE, handle);
	656	return 0;
	657	}