pipe-posix.cpp@ 27503

Last change on this file since 27503 was 27312, checked in by vboxsync, 15 years ago
pipe-posix.cpp: Fixed missing VERR_NO_MEMORY in RTPipeCreate.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 15.1 KB

Line
1	/* $Id: pipe-posix.cpp 27312 2010-03-12 02:24:03Z vboxsync $ */
2	/** @file
3	* IPRT - Anonymous Pipes, POSIX Implementation.
4	*/
5
6	/*
7	* Copyright (C) 2010 Sun Microsystems, Inc.
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*
26	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
27	* Clara, CA 95054 USA or visit http://www.sun.com if you need
28	* additional information or have any questions.
29	*/
30
31
32	/*******************************************************************************
33	* Header Files *
34	*******************************************************************************/
35	#include <iprt/pipe.h>
36	#include "internal/iprt.h"
37
38	#include <iprt/asm.h>
39	#include <iprt/assert.h>
40	#include <iprt/err.h>
41	#include <iprt/mem.h>
42	#include <iprt/string.h>
43	#include <iprt/thread.h>
44	#include "internal/magics.h"
45
46	#include <errno.h>
47	#include <fcntl.h>
48	#include <limits.h>
49	#include <unistd.h>
50	#include <sys/poll.h>
51	#include <signal.h>
52
53
54	/*******************************************************************************
55	* Structures and Typedefs *
56	*******************************************************************************/
57	typedef struct RTPIPEINTERNAL
58	{
59	/** Magic value (RTPIPE_MAGIC). */
60	uint32_t u32Magic;
61	/** The file descriptor. */
62	int fd;
63	/** Set if this is the read end, clear if it's the write end. */
64	bool fRead;
65	/** Atomically operated state variable.
66	*
67	* - Bits 0 thru 29 - Users of the new mode.
68	* - Bit 30 - The pipe mode, set indicates blocking.
69	* - Bit 31 - Set when we're switching the mode.
70	*/
71	uint32_t volatile u32State;
72	} RTPIPEINTERNAL;
73
74
75	/*******************************************************************************
76	* Defined Constants And Macros *
77	*******************************************************************************/
78	/** @name RTPIPEINTERNAL::u32State defines
79	* @{ */
80	#define RTPIPE_POSIX_BLOCKING UINT32_C(0x40000000)
81	#define RTPIPE_POSIX_SWITCHING UINT32_C(0x80000000)
82	#define RTPIPE_POSIX_SWITCHING_BIT 31
83	#define RTPIPE_POSIX_USERS_MASK UINT32_C(0x3fffffff)
84	/** @} */
85
86
87	RTDECL(int) RTPipeCreate(PRTPIPE phPipeRead, PRTPIPE phPipeWrite, uint32_t fFlags)
88	{
89	AssertPtrReturn(phPipeRead, VERR_INVALID_POINTER);
90	AssertPtrReturn(phPipeWrite, VERR_INVALID_POINTER);
91	AssertReturn(!(fFlags & ~RTPIPE_C_VALID_MASK), VERR_INVALID_PARAMETER);
92
93	/*
94	* Create the pipe and set the close-on-exec flag if requested.
95	*/
96	int aFds[2] = {-1, -1};
97	if (pipe(aFds))
98	return RTErrConvertFromErrno(errno);
99
100	int rc = VINF_SUCCESS;
101	if (!(fFlags & RTPIPE_C_INHERIT_READ))
102	{
103	if (fcntl(aFds[0], F_SETFD, FD_CLOEXEC))
104	rc = RTErrConvertFromErrno(errno);
105	}
106
107	if (!(fFlags & RTPIPE_C_INHERIT_WRITE))
108	{
109	if (fcntl(aFds[1], F_SETFD, FD_CLOEXEC))
110	rc = RTErrConvertFromErrno(errno);
111	}
112
113	if (RT_SUCCESS(rc))
114	{
115	/*
116	* Create the two handles.
117	*/
118	RTPIPEINTERNAL pThisR = (RTPIPEINTERNAL )RTMemAlloc(sizeof(RTPIPEINTERNAL));
119	if (pThisR)
120	{
121	RTPIPEINTERNAL pThisW = (RTPIPEINTERNAL )RTMemAlloc(sizeof(RTPIPEINTERNAL));
122	if (pThisW)
123	{
124	pThisR->u32Magic = RTPIPE_MAGIC;
125	pThisW->u32Magic = RTPIPE_MAGIC;
126	pThisR->fd = aFds[0];
127	pThisW->fd = aFds[1];
128	pThisR->fRead = true;
129	pThisW->fRead = false;
130	pThisR->u32State = RTPIPE_POSIX_BLOCKING;
131	pThisW->u32State = RTPIPE_POSIX_BLOCKING;
132
133	*phPipeRead = pThisR;
134	*phPipeWrite = pThisW;
135
136	/*
137	* Before we leave, make sure to shut up SIGPIPE.
138	*/
139	signal(SIGPIPE, SIG_IGN);
140	return VINF_SUCCESS;
141	}
142
143	RTMemFree(pThisR);
144	rc = VERR_NO_MEMORY;
145	}
146	else
147	rc = VERR_NO_MEMORY;
148	}
149
150	close(aFds[0]);
151	close(aFds[1]);
152	return rc;
153	}
154
155
156	RTDECL(int) RTPipeClose(RTPIPE hPipe)
157	{
158	RTPIPEINTERNAL *pThis = hPipe;
159	if (pThis == NIL_RTPIPE)
160	return VINF_SUCCESS;
161	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
162	AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE);
163
164	/*
165	* Do the cleanup.
166	*/
167	AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, ~RTPIPE_MAGIC, RTPIPE_MAGIC), VERR_INVALID_HANDLE);
168
169	int fd = pThis->fd;
170	pThis->fd = -1;
171	close(fd);
172
173	if (ASMAtomicReadU32(&pThis->u32State) & RTPIPE_POSIX_USERS_MASK)
174	{
175	AssertFailed();
176	RTThreadSleep(1);
177	}
178
179	RTMemFree(pThis);
180
181	return VINF_SUCCESS;
182	}
183
184
185	RTDECL(RTHCINTPTR) RTPipeToNative(RTPIPE hPipe)
186	{
187	RTPIPEINTERNAL *pThis = hPipe;
188	AssertPtrReturn(pThis, (RTHCINTPTR)(unsigned int)-1);
189	AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, (RTHCINTPTR)(unsigned int)-1);
190
191	return pThis->fd;
192	}
193
194
195	/**
196	* Prepare blocking mode.
197	*
198	* @returns VINF_SUCCESS
199	* @retval VERR_WRONG_ORDER
200	* @retval VERR_INTERNAL_ERROR_4
201	*
202	* @param pThis The pipe handle.
203	*/
204	static int rtPipeTryBlocking(RTPIPEINTERNAL *pThis)
205	{
206	/*
207	* Update the state.
208	*/
209	for (;;)
210	{
211	uint32_t u32State = ASMAtomicReadU32(&pThis->u32State);
212	uint32_t const u32StateOld = u32State;
213	uint32_t const cUsers = (u32State & RTPIPE_POSIX_USERS_MASK);
214
215	if (u32State & RTPIPE_POSIX_BLOCKING)
216	{
217	AssertReturn(cUsers < RTPIPE_POSIX_USERS_MASK / 2, VERR_INTERNAL_ERROR_4);
218	u32State &= ~RTPIPE_POSIX_USERS_MASK;
219	u32State \|= cUsers + 1;
220	if (ASMAtomicCmpXchgU32(&pThis->u32State, u32State, u32StateOld))
221	{
222	if (u32State & RTPIPE_POSIX_SWITCHING)
223	break;
224	return VINF_SUCCESS;
225	}
226	}
227	else if (cUsers == 0)
228	{
229	u32State = 1 \| RTPIPE_POSIX_SWITCHING \| RTPIPE_POSIX_BLOCKING;
230	if (ASMAtomicCmpXchgU32(&pThis->u32State, u32State, u32StateOld))
231	break;
232	}
233	else
234	return VERR_WRONG_ORDER;
235	ASMNopPause();
236	}
237
238	/*
239	* Do the switching.
240	*/
241	int fFlags = fcntl(pThis->fd, F_GETFL, 0);
242	if (fFlags != -1)
243	{
244	if ( !(fFlags & O_NONBLOCK)
245	\|\| fcntl(pThis->fd, F_SETFL, fFlags & ~O_NONBLOCK) != -1)
246	{
247	ASMAtomicBitClear(&pThis->u32State, RTPIPE_POSIX_SWITCHING_BIT);
248	return VINF_SUCCESS;
249	}
250	}
251
252	ASMAtomicDecU32(&pThis->u32State);
253	return RTErrConvertFromErrno(errno);
254	}
255
256
257	/**
258	* Prepare non-blocking mode.
259	*
260	* @returns VINF_SUCCESS
261	* @retval VERR_WRONG_ORDER
262	* @retval VERR_INTERNAL_ERROR_4
263	*
264	* @param pThis The pipe handle.
265	*/
266	static int rtPipeTryNonBlocking(RTPIPEINTERNAL *pThis)
267	{
268	/*
269	* Update the state.
270	*/
271	for (;;)
272	{
273	uint32_t u32State = ASMAtomicReadU32(&pThis->u32State);
274	uint32_t const u32StateOld = u32State;
275	uint32_t const cUsers = (u32State & RTPIPE_POSIX_USERS_MASK);
276
277	if (!(u32State & RTPIPE_POSIX_BLOCKING))
278	{
279	AssertReturn(cUsers < RTPIPE_POSIX_USERS_MASK / 2, VERR_INTERNAL_ERROR_4);
280	u32State &= ~RTPIPE_POSIX_USERS_MASK;
281	u32State \|= cUsers + 1;
282	if (ASMAtomicCmpXchgU32(&pThis->u32State, u32State, u32StateOld))
283	{
284	if (u32State & RTPIPE_POSIX_SWITCHING)
285	break;
286	return VINF_SUCCESS;
287	}
288	}
289	else if (cUsers == 0)
290	{
291	u32State = 1 \| RTPIPE_POSIX_SWITCHING;
292	if (ASMAtomicCmpXchgU32(&pThis->u32State, u32State, u32StateOld))
293	break;
294	}
295	else
296	return VERR_WRONG_ORDER;
297	ASMNopPause();
298	}
299
300	/*
301	* Do the switching.
302	*/
303	int fFlags = fcntl(pThis->fd, F_GETFL, 0);
304	if (fFlags != -1)
305	{
306	if ( (fFlags & O_NONBLOCK)
307	\|\| fcntl(pThis->fd, F_SETFL, fFlags \| O_NONBLOCK) != -1)
308	{
309	ASMAtomicBitClear(&pThis->u32State, RTPIPE_POSIX_SWITCHING_BIT);
310	return VINF_SUCCESS;
311	}
312	}
313
314	ASMAtomicDecU32(&pThis->u32State);
315	return RTErrConvertFromErrno(errno);
316	}
317
318
319	/**
320	* Checks if the read pipe has a HUP condition.
321	*
322	* @returns true if HUP, false if no.
323	* @param pThis The pipe handle (read).
324	*/
325	static bool rtPipePosixHasHup(RTPIPEINTERNAL *pThis)
326	{
327	Assert(pThis->fRead);
328
329	struct pollfd PollFd;
330	RT_ZERO(PollFd);
331	PollFd.fd = pThis->fd;
332	PollFd.events = POLLHUP;
333	return poll(&PollFd, 1, 0) >= 1
334	&& (PollFd.revents & POLLHUP);
335	}
336
337
338	RTDECL(int) RTPipeRead(RTPIPE hPipe, void pvBuf, size_t cbToRead, size_t pcbRead)
339	{
340	RTPIPEINTERNAL *pThis = hPipe;
341	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
342	AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE);
343	AssertReturn(pThis->fRead, VERR_ACCESS_DENIED);
344	AssertPtr(pcbRead);
345	AssertPtr(pvBuf);
346
347	int rc = rtPipeTryNonBlocking(pThis);
348	if (RT_SUCCESS(rc))
349	{
350	ssize_t cbRead = read(pThis->fd, pvBuf, RT_MIN(cbToRead, SSIZE_MAX));
351	if (cbRead >= 0)
352	{
353	if (cbRead \|\| !cbToRead \|\| !rtPipePosixHasHup(pThis))
354	*pcbRead = cbRead;
355	else
356	rc = VERR_BROKEN_PIPE;
357	}
358	else if (errno == EAGAIN)
359	{
360	*pcbRead = 0;
361	rc = VINF_TRY_AGAIN;
362	}
363	else
364	rc = RTErrConvertFromErrno(errno);
365
366	ASMAtomicDecU32(&pThis->u32State);
367	}
368	return rc;
369	}
370
371
372	RTDECL(int) RTPipeReadBlocking(RTPIPE hPipe, void pvBuf, size_t cbToRead, size_t pcbRead)
373	{
374	RTPIPEINTERNAL *pThis = hPipe;
375	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
376	AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE);
377	AssertReturn(pThis->fRead, VERR_ACCESS_DENIED);
378	AssertPtr(pvBuf);
379
380	int rc = rtPipeTryBlocking(pThis);
381	if (RT_SUCCESS(rc))
382	{
383	size_t cbTotalRead = 0;;
384	while (cbToRead > 0)
385	{
386	ssize_t cbRead = read(pThis->fd, pvBuf, RT_MIN(cbToRead, SSIZE_MAX));
387	if (cbRead < 0)
388	{
389	rc = RTErrConvertFromErrno(errno);
390	break;
391	}
392	if (!cbRead && cbToRead > 0 && rtPipePosixHasHup(pThis))
393	{
394	rc = VERR_BROKEN_PIPE;
395	break;
396	}
397
398	/* advance */
399	pvBuf = (char *)pvBuf + cbRead;
400	cbTotalRead += cbRead;
401	cbToRead -= cbRead;
402	}
403
404	if (pcbRead)
405	{
406	*pcbRead = cbTotalRead;
407	if ( RT_FAILURE(rc)
408	&& cbTotalRead
409	&& rc != VERR_INVALID_POINTER)
410	rc = VINF_SUCCESS;
411	}
412
413	ASMAtomicDecU32(&pThis->u32State);
414	}
415	return rc;
416	}
417
418
419	RTDECL(int) RTPipeWrite(RTPIPE hPipe, const void pvBuf, size_t cbToWrite, size_t pcbWritten)
420	{
421	RTPIPEINTERNAL *pThis = hPipe;
422	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
423	AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE);
424	AssertReturn(!pThis->fRead, VERR_ACCESS_DENIED);
425	AssertPtr(pcbWritten);
426	AssertPtr(pvBuf);
427
428	int rc = rtPipeTryNonBlocking(pThis);
429	if (RT_SUCCESS(rc))
430	{
431	if (cbToWrite)
432	{
433	ssize_t cbWritten = write(pThis->fd, pvBuf, RT_MIN(cbToWrite, SSIZE_MAX));
434	if (cbWritten >= 0)
435	*pcbWritten = cbWritten;
436	else if (errno == EAGAIN)
437	{
438	*pcbWritten = 0;
439	rc = VINF_TRY_AGAIN;
440	}
441	else
442	rc = RTErrConvertFromErrno(errno);
443	}
444	else
445	*pcbWritten = 0;
446
447	ASMAtomicDecU32(&pThis->u32State);
448	}
449	return rc;
450	}
451
452
453	RTDECL(int) RTPipeWriteBlocking(RTPIPE hPipe, const void pvBuf, size_t cbToWrite, size_t pcbWritten)
454	{
455	RTPIPEINTERNAL *pThis = hPipe;
456	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
457	AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE);
458	AssertReturn(!pThis->fRead, VERR_ACCESS_DENIED);
459	AssertPtr(pvBuf);
460	AssertPtrNull(pcbWritten);
461
462	int rc = rtPipeTryBlocking(pThis);
463	if (RT_SUCCESS(rc))
464	{
465	size_t cbTotalWritten = 0;
466	while (cbToWrite > 0)
467	{
468	ssize_t cbWritten = write(pThis->fd, pvBuf, RT_MIN(cbToWrite, SSIZE_MAX));
469	if (cbWritten < 0)
470	{
471	rc = RTErrConvertFromErrno(errno);
472	break;
473	}
474
475	/* advance */
476	pvBuf = (char const *)pvBuf + cbWritten;
477	cbTotalWritten += cbWritten;
478	cbToWrite -= cbWritten;
479	}
480
481	if (pcbWritten)
482	{
483	*pcbWritten = cbTotalWritten;
484	if ( RT_FAILURE(rc)
485	&& cbTotalWritten
486	&& rc != VERR_INVALID_POINTER)
487	rc = VINF_SUCCESS;
488	}
489
490	ASMAtomicDecU32(&pThis->u32State);
491	}
492	return rc;
493	}
494
495
496	RTDECL(int) RTPipeFlush(RTPIPE hPipe)
497	{
498	RTPIPEINTERNAL *pThis = hPipe;
499	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
500	AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE);
501	AssertReturn(!pThis->fRead, VERR_ACCESS_DENIED);
502
503	if (fsync(pThis->fd))
504	{
505	if (errno == EINVAL \|\| errno == ENOTSUP)
506	return VERR_NOT_SUPPORTED;
507	return RTErrConvertFromErrno(errno);
508	}
509	return VINF_SUCCESS;
510	}
511
512
513	RTDECL(int) RTPipeSelectOne(RTPIPE hPipe, RTMSINTERVAL cMillies)
514	{
515	RTPIPEINTERNAL *pThis = hPipe;
516	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
517	AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE);
518
519	struct pollfd PollFd;
520	RT_ZERO(PollFd);
521	PollFd.fd = pThis->fd;
522	PollFd.events = POLLHUP \| POLLERR;
523	if (pThis->fRead)
524	PollFd.events \|= POLLIN \| POLLPRI;
525	else
526	PollFd.events \|= POLLOUT;
527
528	int timeout;
529	if ( cMillies == RT_INDEFINITE_WAIT
530	\|\| cMillies >= INT_MAX /* lazy bird */)
531	timeout = -1;
532	else
533	timeout = cMillies;
534
535	int rc = poll(&PollFd, 1, 0);
536	if (rc == -1)
537	return RTErrConvertFromErrno(errno);
538	return rc > 0 ? VINF_SUCCESS : VERR_TIMEOUT;
539	}
540

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/r3/posix/pipe-posix.cpp@ 27503

Download in other formats: