[lttng-tools.git] / src / common / pipe.c

/*
 * Copyright (C) 2013 - David Goulet <dgoulet@efficios.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License, version 2 only, as
 * published by the Free Software Foundation.
 *
 * 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., 51
 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#define _LGPL_SOURCE
#include <assert.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>

#include <common/common.h>

#include "pipe.h"

/*
 * Lock read side of a pipe.
 */
static void lock_read_side(struct lttng_pipe *pipe)
{
	pthread_mutex_lock(&pipe->read_mutex);
}

/*
 * Unlock read side of a pipe.
 */
static void unlock_read_side(struct lttng_pipe *pipe)
{
	pthread_mutex_unlock(&pipe->read_mutex);
}

/*
 * Lock write side of a pipe.
 */
static void lock_write_side(struct lttng_pipe *pipe)
{
	pthread_mutex_lock(&pipe->write_mutex);
}

/*
 * Unlock write side of a pipe.
 */
static void unlock_write_side(struct lttng_pipe *pipe)
{
	pthread_mutex_unlock(&pipe->write_mutex);
}

/*
 * Internal function. Close read side of pipe WITHOUT locking the mutex.
 *
 * Return 0 on success else a negative errno from close(2).
 */
static int _pipe_read_close(struct lttng_pipe *pipe)
{
	int ret, ret_val = 0;

	assert(pipe);

	if (!lttng_pipe_is_read_open(pipe)) {
		goto end;
	}

	do {
		ret = close(pipe->fd[0]);
	} while (ret < 0 && errno == EINTR);
	if (ret < 0) {
		PERROR("close lttng read pipe");
		ret_val = -errno;
	}
	pipe->r_state = LTTNG_PIPE_STATE_CLOSED;

end:
	return ret_val;
}

/*
 * Internal function. Close write side of pipe WITHOUT locking the mutex.
 *
 * Return 0 on success else a negative errno from close(2).
 */
static int _pipe_write_close(struct lttng_pipe *pipe)
{
	int ret, ret_val = 0;

	assert(pipe);

	if (!lttng_pipe_is_write_open(pipe)) {
		goto end;
	}

	do {
		ret = close(pipe->fd[1]);
	} while (ret < 0 && errno == EINTR);
	if (ret < 0) {
		PERROR("close lttng write pipe");
		ret_val = -errno;
	}
	pipe->w_state = LTTNG_PIPE_STATE_CLOSED;

end:
	return ret_val;
}

static struct lttng_pipe *_pipe_create(void)
{
	int ret;
	struct lttng_pipe *p;

	p = zmalloc(sizeof(*p));
	if (!p) {
		PERROR("zmalloc pipe create");
		goto end;
	}
	p->fd[0] = p->fd[1] = -1;

	ret = pthread_mutex_init(&p->read_mutex, NULL);
	if (ret) {
		PERROR("pthread_mutex_init read lock pipe create");
		goto error_destroy;
	}
	ret = pthread_mutex_init(&p->write_mutex, NULL);
	if (ret) {
		PERROR("pthread_mutex_init write lock pipe create");
		goto error_destroy_rmutex;
	}
end:
	return p;
error_destroy_rmutex:
	(void) pthread_mutex_destroy(&p->read_mutex);
error_destroy:
	free(p);
	return NULL;
}

static int _pipe_set_flags(struct lttng_pipe *pipe, int flags)
{
	int i, ret = 0;

	if (!flags) {
		goto end;
	}

	for (i = 0; i < 2; i++) {
		if (flags & O_NONBLOCK) {
			ret = fcntl(pipe->fd[i], F_SETFL, O_NONBLOCK);
			if (ret < 0) {
				PERROR("fcntl lttng pipe %d", flags);
				goto end;
			}
		}
		if (flags & FD_CLOEXEC) {
			ret = fcntl(pipe->fd[i], F_SETFD, FD_CLOEXEC);
			if (ret < 0) {
				PERROR("fcntl lttng pipe %d", flags);
				goto end;
			}
		}
		/*
		 * We only check for O_NONBLOCK or FD_CLOEXEC, if another flag is
		 * needed, we can add it, but for now just make sure we don't make
		 * mistakes with the parameters we pass.
		 */
		if (!(flags & O_NONBLOCK) && !(flags & FD_CLOEXEC)) {
			fprintf(stderr, "Unsupported flag\n");
			ret = -1;
			goto end;
		}
	}
end:
	return ret;
}

/*
 * Open a new lttng pipe and set flags using fcntl().
 *
 * Return a newly allocated lttng pipe on success or else NULL.
 */
LTTNG_HIDDEN
struct lttng_pipe *lttng_pipe_open(int flags)
{
	int ret;
	struct lttng_pipe *p;

	p = _pipe_create();
	if (!p) {
		goto error;
	}

	ret = pipe(p->fd);
	if (ret < 0) {
		PERROR("lttng pipe");
		goto error;
	}
	p->r_state = LTTNG_PIPE_STATE_OPENED;
	p->w_state = LTTNG_PIPE_STATE_OPENED;

	ret = _pipe_set_flags(p, flags);
	if (ret) {
		goto error;
	}

	p->flags = flags;

	return p;
error:
	lttng_pipe_destroy(p);
	return NULL;
}

/*
 * Open a new lttng pipe at path and set flags using fcntl().
 *
 * Return a newly allocated lttng pipe on success or else NULL.
 */
LTTNG_HIDDEN
struct lttng_pipe *lttng_pipe_named_open(const char *path, mode_t mode,
		int flags)
{
	int ret, fd_r, fd_w;
	struct lttng_pipe *pipe;

	pipe = _pipe_create();
	if (!pipe) {
		goto error;
	}

	ret = mkfifo(path, mode);
	if (ret) {
		PERROR("mkfifo");
		goto error;
	}

	fd_r = open(path, O_RDONLY | O_NONBLOCK);
	if (fd_r < 0) {
		PERROR("open fifo");
		goto error;
	}
	pipe->fd[0] = fd_r;
	pipe->r_state = LTTNG_PIPE_STATE_OPENED;

	fd_w = open(path, O_WRONLY | O_NONBLOCK);
	if (fd_w < 0) {
		PERROR("open fifo");
		goto error;
	}
	pipe->fd[1] = fd_w;
	pipe->w_state = LTTNG_PIPE_STATE_OPENED;

	ret = _pipe_set_flags(pipe, flags);
	if (ret) {
		goto error;
	}
	pipe->flags = flags;

	return pipe;
error:
	lttng_pipe_destroy(pipe);
	return NULL;
}

/*
 * Close read side of a lttng pipe.
 *
 * Return 0 on success else a negative value.
 */
LTTNG_HIDDEN
int lttng_pipe_read_close(struct lttng_pipe *pipe)
{
	int ret;

	assert(pipe);

	/* Handle read side first. */
	lock_read_side(pipe);
	ret = _pipe_read_close(pipe);
	unlock_read_side(pipe);

	return ret;
}

/*
 * Close write side of a lttng pipe.
 *
 * Return 0 on success else a negative value.
 */
LTTNG_HIDDEN
int lttng_pipe_write_close(struct lttng_pipe *pipe)
{
	int ret;

	assert(pipe);

	lock_write_side(pipe);
	ret = _pipe_write_close(pipe);
	unlock_write_side(pipe);

	return ret;
}

/*
 * Close both read and write side of a lttng pipe.
 *
 * Return 0 on success else a negative value.
 */
LTTNG_HIDDEN
int lttng_pipe_close(struct lttng_pipe *pipe)
{
	int ret, ret_val = 0;

	assert(pipe);

	ret = lttng_pipe_read_close(pipe);
	if (ret < 0) {
		ret_val = ret;
	}

	ret = lttng_pipe_write_close(pipe);
	if (ret < 0) {
		ret_val = ret;
	}

	return ret_val;
}

/*
 * Close and destroy a lttng pipe object. Finally, pipe is freed.
 */
LTTNG_HIDDEN
void lttng_pipe_destroy(struct lttng_pipe *pipe)
{
	int ret;

	if (!pipe) {
		return;
	}

	/*
	 * Destroy should *never* be called with a locked mutex. These must always
	 * succeed so we unlock them after the close pipe below.
	 */
	ret = pthread_mutex_trylock(&pipe->read_mutex);
	assert(!ret);
	ret = pthread_mutex_trylock(&pipe->write_mutex);
	assert(!ret);

	/* Close pipes WITHOUT trying to lock the pipes. */
	(void) _pipe_read_close(pipe);
	(void) _pipe_write_close(pipe);

	unlock_read_side(pipe);
	unlock_write_side(pipe);

	(void) pthread_mutex_destroy(&pipe->read_mutex);
	(void) pthread_mutex_destroy(&pipe->write_mutex);

	free(pipe);
}

/*
 * Read on a lttng pipe and put the data in buf of at least size count.
 *
 * Return "count" on success. Return < count on error. errno can be used
 * to check the actual error.
 */
LTTNG_HIDDEN
ssize_t lttng_pipe_read(struct lttng_pipe *pipe, void *buf, size_t count)
{
	ssize_t ret;

	assert(pipe);
	assert(buf);

	lock_read_side(pipe);
	if (!lttng_pipe_is_read_open(pipe)) {
		ret = -1;
		errno = EBADF;
		goto error;
	}
	ret = lttng_read(pipe->fd[0], buf, count);
error:
	unlock_read_side(pipe);
	return ret;
}

/*
 * Write on a lttng pipe using the data in buf and size of count.
 *
 * Return "count" on success. Return < count on error. errno can be used
 * to check the actual error.
 */
LTTNG_HIDDEN
ssize_t lttng_pipe_write(struct lttng_pipe *pipe, const void *buf,
		size_t count)
{
	ssize_t ret;

	assert(pipe);
	assert(buf);

	lock_write_side(pipe);
	if (!lttng_pipe_is_write_open(pipe)) {
		ret = -1;
		errno = EBADF;
		goto error;
	}
	ret = lttng_write(pipe->fd[1], buf, count);
error:
	unlock_write_side(pipe);
	return ret;
}

/*
 * Return and release the read end of the pipe.
 *
 * This call transfers the ownership of the read fd of the underlying pipe
 * to the caller if it is still open.
 *
 * Returns the fd of the read end of the pipe, or -1 if it was already closed or
 * released.
 */
LTTNG_HIDDEN
int lttng_pipe_release_readfd(struct lttng_pipe *pipe)
{
	int ret;

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

	lock_read_side(pipe);
	if (!lttng_pipe_is_read_open(pipe)) {
		ret = -1;
		goto end_unlock;
	}
	ret = pipe->fd[0];
	pipe->fd[0] = -1;
	pipe->r_state = LTTNG_PIPE_STATE_CLOSED;
end_unlock:
	unlock_read_side(pipe);
end:
	return ret;
}

/*
 * Return and release the write end of the pipe.
 *
 * This call transfers the ownership of the write fd of the underlying pipe
 * to the caller if it is still open.
 *
 * Returns the fd of the write end of the pipe, or -1 if it was alwritey closed
 * or released.
 */
LTTNG_HIDDEN
int lttng_pipe_release_writefd(struct lttng_pipe *pipe)
{
	int ret;

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

	lock_write_side(pipe);
	if (!lttng_pipe_is_write_open(pipe)) {
		ret = -1;
		goto end_unlock;
	}
	ret = pipe->fd[1];
	pipe->fd[1] = -1;
	pipe->w_state = LTTNG_PIPE_STATE_CLOSED;
end_unlock:
	unlock_write_side(pipe);
end:
	return ret;
}
Commit	Line	Data
9fd92637 DG	1	/*
	2	* Copyright (C) 2013 - David Goulet <dgoulet@efficios.com>
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms of the GNU General Public License, version 2 only, as
	6	* published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful, but WITHOUT
	9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	10	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	11	* more details.
	12	*
	13	* You should have received a copy of the GNU General Public License along with
	14	* this program; if not, write to the Free Software Foundation, Inc., 51
	15	* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	16	*/
	17
6c1c0768	18	#define _LGPL_SOURCE
9fd92637 DG	19	#include <assert.h>
	20	#include <fcntl.h>
	21	#include <unistd.h>
9c2bd8db JG	22	#include <sys/types.h>
9c2bd8db JG	23	#include <sys/stat.h>
9fd92637 DG	24
	25	#include <common/common.h>
	26
	27	#include "pipe.h"
	28
	29	/*
	30	* Lock read side of a pipe.
	31	*/
	32	static void lock_read_side(struct lttng_pipe *pipe)
	33	{
	34	pthread_mutex_lock(&pipe->read_mutex);
	35	}
	36
	37	/*
	38	* Unlock read side of a pipe.
	39	*/
	40	static void unlock_read_side(struct lttng_pipe *pipe)
	41	{
	42	pthread_mutex_unlock(&pipe->read_mutex);
	43	}
	44
	45	/*
	46	* Lock write side of a pipe.
	47	*/
	48	static void lock_write_side(struct lttng_pipe *pipe)
	49	{
	50	pthread_mutex_lock(&pipe->write_mutex);
	51	}
	52
	53	/*
	54	* Unlock write side of a pipe.
	55	*/
	56	static void unlock_write_side(struct lttng_pipe *pipe)
	57	{
	58	pthread_mutex_unlock(&pipe->write_mutex);
	59	}
	60
	61	/*
	62	* Internal function. Close read side of pipe WITHOUT locking the mutex.
	63	*
	64	* Return 0 on success else a negative errno from close(2).
	65	*/
	66	static int _pipe_read_close(struct lttng_pipe *pipe)
	67	{
	68	int ret, ret_val = 0;
	69
	70	assert(pipe);
	71
	72	if (!lttng_pipe_is_read_open(pipe)) {
	73	goto end;
	74	}
	75
	76	do {
	77	ret = close(pipe->fd[0]);
	78	} while (ret < 0 && errno == EINTR);
	79	if (ret < 0) {
	80	PERROR("close lttng read pipe");
	81	ret_val = -errno;
	82	}
	83	pipe->r_state = LTTNG_PIPE_STATE_CLOSED;
	84
	85	end:
	86	return ret_val;
	87	}
88
89	/*
90	* Internal function. Close write side of pipe WITHOUT locking the mutex.
91	*
92	* Return 0 on success else a negative errno from close(2).
93	*/
94	static int _pipe_write_close(struct lttng_pipe *pipe)
95	{
96	int ret, ret_val = 0;
97
98	assert(pipe);
99
100	if (!lttng_pipe_is_write_open(pipe)) {
101	goto end;
102	}
103
104	do {
105	ret = close(pipe->fd[1]);
106	} while (ret < 0 && errno == EINTR);
107	if (ret < 0) {
108	PERROR("close lttng write pipe");
109	ret_val = -errno;
110	}
111	pipe->w_state = LTTNG_PIPE_STATE_CLOSED;
112
113	end:
114	return ret_val;
115	}
116
9c2bd8db JG	117	static struct lttng_pipe *_pipe_create(void)
	118	{
	119	int ret;
	120	struct lttng_pipe *p;
	121
	122	p = zmalloc(sizeof(*p));
	123	if (!p) {
	124	PERROR("zmalloc pipe create");
	125	goto end;
	126	}
	127	p->fd[0] = p->fd[1] = -1;
	128
	129	ret = pthread_mutex_init(&p->read_mutex, NULL);
	130	if (ret) {
	131	PERROR("pthread_mutex_init read lock pipe create");
	132	goto error_destroy;
	133	}
	134	ret = pthread_mutex_init(&p->write_mutex, NULL);
	135	if (ret) {
	136	PERROR("pthread_mutex_init write lock pipe create");
	137	goto error_destroy_rmutex;
	138	}
	139	end:
	140	return p;
	141	error_destroy_rmutex:
	142	(void) pthread_mutex_destroy(&p->read_mutex);
	143	error_destroy:
	144	free(p);
	145	return NULL;
	146	}
	147
	148	static int _pipe_set_flags(struct lttng_pipe *pipe, int flags)
	149	{
	150	int i, ret = 0;
	151
	152	if (!flags) {
	153	goto end;
	154	}
	155
	156	for (i = 0; i < 2; i++) {
699f8738 JD	157	if (flags & O_NONBLOCK) {
	158	ret = fcntl(pipe->fd[i], F_SETFL, O_NONBLOCK);
	159	if (ret < 0) {
	160	PERROR("fcntl lttng pipe %d", flags);
	161	goto end;
	162	}
	163	}
	164	if (flags & FD_CLOEXEC) {
	165	ret = fcntl(pipe->fd[i], F_SETFD, FD_CLOEXEC);
	166	if (ret < 0) {
	167	PERROR("fcntl lttng pipe %d", flags);
	168	goto end;
	169	}
	170	}
	171	/*
	172	* We only check for O_NONBLOCK or FD_CLOEXEC, if another flag is
	173	* needed, we can add it, but for now just make sure we don't make
	174	* mistakes with the parameters we pass.
	175	*/
	176	if (!(flags & O_NONBLOCK) && !(flags & FD_CLOEXEC)) {
	177	fprintf(stderr, "Unsupported flag\n");
	178	ret = -1;
9c2bd8db JG	179	goto end;
	180	}
	181	}
	182	end:
	183	return ret;
	184	}
9fd92637 DG	185
	186	/*
	187	* Open a new lttng pipe and set flags using fcntl().
	188	*
	189	* Return a newly allocated lttng pipe on success or else NULL.
	190	*/
a247c6e0	191	LTTNG_HIDDEN
9fd92637 DG	192	struct lttng_pipe *lttng_pipe_open(int flags)
	193	{
	194	int ret;
	195	struct lttng_pipe *p;
	196
9c2bd8db	197	p = _pipe_create();
9fd92637	198	if (!p) {
9fd92637 DG	199	goto error;
	200	}
	201
	202	ret = pipe(p->fd);
	203	if (ret < 0) {
	204	PERROR("lttng pipe");
	205	goto error;
	206	}
9c2bd8db JG	207	p->r_state = LTTNG_PIPE_STATE_OPENED;
9c2bd8db JG	208	p->w_state = LTTNG_PIPE_STATE_OPENED;
9fd92637	209
9c2bd8db JG	210	ret = _pipe_set_flags(p, flags);
	211	if (ret) {
	212	goto error;
9fd92637 DG	213	}
9fd92637 DG	214
9fd92637 DG	215	p->flags = flags;
	216
	217	return p;
9fd92637 DG	218	error:
	219	lttng_pipe_destroy(p);
	220	return NULL;
	221	}
	222
9c2bd8db JG	223	/*
	224	* Open a new lttng pipe at path and set flags using fcntl().
	225	*
	226	* Return a newly allocated lttng pipe on success or else NULL.
	227	*/
	228	LTTNG_HIDDEN
	229	struct lttng_pipe lttng_pipe_named_open(const char path, mode_t mode,
	230	int flags)
	231	{
	232	int ret, fd_r, fd_w;
	233	struct lttng_pipe *pipe;
	234
	235	pipe = _pipe_create();
	236	if (!pipe) {
	237	goto error;
	238	}
	239
	240	ret = mkfifo(path, mode);
	241	if (ret) {
	242	PERROR("mkfifo");
	243	goto error;
	244	}
	245
	246	fd_r = open(path, O_RDONLY \| O_NONBLOCK);
	247	if (fd_r < 0) {
	248	PERROR("open fifo");
9c2bd8db JG	249	goto error;
	250	}
	251	pipe->fd[0] = fd_r;
	252	pipe->r_state = LTTNG_PIPE_STATE_OPENED;
	253
	254	fd_w = open(path, O_WRONLY \| O_NONBLOCK);
	255	if (fd_w < 0) {
	256	PERROR("open fifo");
9c2bd8db JG	257	goto error;
	258	}
	259	pipe->fd[1] = fd_w;
	260	pipe->w_state = LTTNG_PIPE_STATE_OPENED;
	261
	262	ret = _pipe_set_flags(pipe, flags);
	263	if (ret) {
	264	goto error;
	265	}
	266	pipe->flags = flags;
	267
	268	return pipe;
	269	error:
	270	lttng_pipe_destroy(pipe);
	271	return NULL;
	272	}
	273
9fd92637 DG	274	/*
	275	* Close read side of a lttng pipe.
	276	*
	277	* Return 0 on success else a negative value.
	278	*/
a247c6e0	279	LTTNG_HIDDEN
9fd92637 DG	280	int lttng_pipe_read_close(struct lttng_pipe *pipe)
	281	{
	282	int ret;
	283
	284	assert(pipe);
	285
	286	/* Handle read side first. */
	287	lock_read_side(pipe);
	288	ret = _pipe_read_close(pipe);
	289	unlock_read_side(pipe);
	290
	291	return ret;
	292	}
	293
	294	/*
	295	* Close write side of a lttng pipe.
	296	*
	297	* Return 0 on success else a negative value.
	298	*/
a247c6e0	299	LTTNG_HIDDEN
9fd92637 DG	300	int lttng_pipe_write_close(struct lttng_pipe *pipe)
	301	{
	302	int ret;
	303
	304	assert(pipe);
	305
	306	lock_write_side(pipe);
	307	ret = _pipe_write_close(pipe);
	308	unlock_write_side(pipe);
	309
	310	return ret;
	311	}
	312
	313	/*
	314	* Close both read and write side of a lttng pipe.
	315	*
	316	* Return 0 on success else a negative value.
	317	*/
a247c6e0	318	LTTNG_HIDDEN
9fd92637 DG	319	int lttng_pipe_close(struct lttng_pipe *pipe)
	320	{
	321	int ret, ret_val = 0;
	322
	323	assert(pipe);
	324
	325	ret = lttng_pipe_read_close(pipe);
	326	if (ret < 0) {
	327	ret_val = ret;
	328	}
	329
	330	ret = lttng_pipe_write_close(pipe);
	331	if (ret < 0) {
	332	ret_val = ret;
	333	}
	334
	335	return ret_val;
	336	}
	337
	338	/*
	339	* Close and destroy a lttng pipe object. Finally, pipe is freed.
	340	*/
a247c6e0	341	LTTNG_HIDDEN
9fd92637 DG	342	void lttng_pipe_destroy(struct lttng_pipe *pipe)
	343	{
	344	int ret;
	345
	346	if (!pipe) {
	347	return;
	348	}
	349
	350	/*
	351	* Destroy should never be called with a locked mutex. These must always
	352	* succeed so we unlock them after the close pipe below.
	353	*/
	354	ret = pthread_mutex_trylock(&pipe->read_mutex);
	355	assert(!ret);
	356	ret = pthread_mutex_trylock(&pipe->write_mutex);
	357	assert(!ret);
	358
	359	/* Close pipes WITHOUT trying to lock the pipes. */
	360	(void) _pipe_read_close(pipe);
	361	(void) _pipe_write_close(pipe);
	362
	363	unlock_read_side(pipe);
	364	unlock_write_side(pipe);
	365
	366	(void) pthread_mutex_destroy(&pipe->read_mutex);
	367	(void) pthread_mutex_destroy(&pipe->write_mutex);
	368
	369	free(pipe);
	370	}
	371
	372	/*
	373	* Read on a lttng pipe and put the data in buf of at least size count.
	374	*
6cd525e8 MD	375	* Return "count" on success. Return < count on error. errno can be used
6cd525e8 MD	376	* to check the actual error.
9fd92637	377	*/
a247c6e0	378	LTTNG_HIDDEN
9fd92637 DG	379	ssize_t lttng_pipe_read(struct lttng_pipe pipe, void buf, size_t count)
9fd92637 DG	380	{
6cd525e8	381	ssize_t ret;
9fd92637 DG	382
	383	assert(pipe);
	384	assert(buf);
	385
	386	lock_read_side(pipe);
9fd92637	387	if (!lttng_pipe_is_read_open(pipe)) {
6cd525e8 MD	388	ret = -1;
6cd525e8 MD	389	errno = EBADF;
9fd92637 DG	390	goto error;
9fd92637 DG	391	}
6cd525e8	392	ret = lttng_read(pipe->fd[0], buf, count);
9fd92637 DG	393	error:
	394	unlock_read_side(pipe);
	395	return ret;
	396	}
	397
	398	/*
	399	* Write on a lttng pipe using the data in buf and size of count.
	400	*
6cd525e8 MD	401	* Return "count" on success. Return < count on error. errno can be used
6cd525e8 MD	402	* to check the actual error.
9fd92637	403	*/
a247c6e0	404	LTTNG_HIDDEN
9fd92637 DG	405	ssize_t lttng_pipe_write(struct lttng_pipe pipe, const void buf,
	406	size_t count)
	407	{
6cd525e8	408	ssize_t ret;
9fd92637 DG	409
	410	assert(pipe);
	411	assert(buf);
	412
	413	lock_write_side(pipe);
9fd92637	414	if (!lttng_pipe_is_write_open(pipe)) {
6cd525e8 MD	415	ret = -1;
6cd525e8 MD	416	errno = EBADF;
9fd92637 DG	417	goto error;
9fd92637 DG	418	}
6cd525e8	419	ret = lttng_write(pipe->fd[1], buf, count);
9fd92637 DG	420	error:
	421	unlock_write_side(pipe);
	422	return ret;
	423	}
55dfb029 JG	424
	425	/*
	426	* Return and release the read end of the pipe.
	427	*
	428	* This call transfers the ownership of the read fd of the underlying pipe
	429	* to the caller if it is still open.
	430	*
	431	* Returns the fd of the read end of the pipe, or -1 if it was already closed or
	432	* released.
	433	*/
	434	LTTNG_HIDDEN
	435	int lttng_pipe_release_readfd(struct lttng_pipe *pipe)
	436	{
	437	int ret;
	438
	439	if (!pipe) {
	440	ret = -1;
	441	goto end;
	442	}
	443
	444	lock_read_side(pipe);
	445	if (!lttng_pipe_is_read_open(pipe)) {
	446	ret = -1;
	447	goto end_unlock;
	448	}
	449	ret = pipe->fd[0];
	450	pipe->fd[0] = -1;
	451	pipe->r_state = LTTNG_PIPE_STATE_CLOSED;
	452	end_unlock:
	453	unlock_read_side(pipe);
	454	end:
	455	return ret;
	456	}
	457
	458	/*
	459	* Return and release the write end of the pipe.
	460	*
	461	* This call transfers the ownership of the write fd of the underlying pipe
	462	* to the caller if it is still open.
	463	*
	464	* Returns the fd of the write end of the pipe, or -1 if it was alwritey closed
	465	* or released.
	466	*/
	467	LTTNG_HIDDEN
	468	int lttng_pipe_release_writefd(struct lttng_pipe *pipe)
	469	{
	470	int ret;
	471
	472	if (!pipe) {
	473	ret = -1;
	474	goto end;
	475	}
	476
	477	lock_write_side(pipe);
	478	if (!lttng_pipe_is_write_open(pipe)) {
	479	ret = -1;
	480	goto end_unlock;
	481	}
	482	ret = pipe->fd[1];
	483	pipe->fd[1] = -1;
	484	pipe->w_state = LTTNG_PIPE_STATE_CLOSED;
	485	end_unlock:
	486	unlock_write_side(pipe);
	487	end:
488	return ret;
489	}