fileaio-freebsd.cpp@ 57358

Last change on this file since 57358 was 57358, checked in by vboxsync, 9 years ago
*: scm cleanup run.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 22.5 KB

Line
1	/* $Id: fileaio-freebsd.cpp 57358 2015-08-14 15:16:38Z vboxsync $ */
2	/** @file
3	* IPRT - File async I/O, native implementation for the FreeBSD host platform.
4	*/
5
6	/*
7	* Copyright (C) 2006-2015 Oracle Corporation
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
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#define LOG_GROUP RTLOGGROUP_FILE
32	#include <iprt/asm.h>
33	#include <iprt/file.h>
34	#include <iprt/mem.h>
35	#include <iprt/assert.h>
36	#include <iprt/string.h>
37	#include <iprt/err.h>
38	#include <iprt/log.h>
39	#include <iprt/thread.h>
40	#include "internal/fileaio.h"
41
42	#include <sys/types.h>
43	#include <sys/event.h>
44	#include <sys/time.h>
45	#include <sys/sysctl.h>
46	#include <aio.h>
47	#include <errno.h>
48	#include <unistd.h>
49	#include <fcntl.h>
50
51
52	/*********************************************************************************************************************************
53	* Structures and Typedefs *
54	*********************************************************************************************************************************/
55	/**
56	* Async I/O completion context state.
57	*/
58	typedef struct RTFILEAIOCTXINTERNAL
59	{
60	/** Handle to the kernel queue. */
61	int iKQueue;
62	/** Current number of requests active on this context. */
63	volatile int32_t cRequests;
64	/** The ID of the thread which is currently waiting for requests. */
65	volatile RTTHREAD hThreadWait;
66	/** Flag whether the thread was woken up. */
67	volatile bool fWokenUp;
68	/** Flag whether the thread is currently waiting in the syscall. */
69	volatile bool fWaiting;
70	/** Flags given during creation. */
71	uint32_t fFlags;
72	/** Magic value (RTFILEAIOCTX_MAGIC). */
73	uint32_t u32Magic;
74	} RTFILEAIOCTXINTERNAL;
75	/** Pointer to an internal context structure. */
76	typedef RTFILEAIOCTXINTERNAL *PRTFILEAIOCTXINTERNAL;
77
78	/**
79	* Async I/O request state.
80	*/
81	typedef struct RTFILEAIOREQINTERNAL
82	{
83	/** The aio control block. Must be the FIRST
84	* element. */
85	struct aiocb AioCB;
86	/** Current state the request is in. */
87	RTFILEAIOREQSTATE enmState;
88	/** Flag whether this is a flush request. */
89	bool fFlush;
90	/** Opaque user data. */
91	void *pvUser;
92	/** Completion context we are assigned to. */
93	PRTFILEAIOCTXINTERNAL pCtxInt;
94	/** Number of bytes actually transferred. */
95	size_t cbTransfered;
96	/** Status code. */
97	int Rc;
98	/** Magic value (RTFILEAIOREQ_MAGIC). */
99	uint32_t u32Magic;
100	} RTFILEAIOREQINTERNAL;
101	/** Pointer to an internal request structure. */
102	typedef RTFILEAIOREQINTERNAL *PRTFILEAIOREQINTERNAL;
103
104
105	/*********************************************************************************************************************************
106	* Defined Constants And Macros *
107	*********************************************************************************************************************************/
108	/** The max number of events to get in one call. */
109	#define AIO_MAXIMUM_REQUESTS_PER_CONTEXT 64
110
111	RTR3DECL(int) RTFileAioGetLimits(PRTFILEAIOLIMITS pAioLimits)
112	{
113	int rcBSD = 0;
114	AssertPtrReturn(pAioLimits, VERR_INVALID_POINTER);
115
116	/*
117	* The AIO API is implemented in a kernel module which is not
118	* loaded by default.
119	* If it is loaded there are additional sysctl parameters.
120	*/
121	int cReqsOutstandingMax = 0;
122	size_t cbParameter = sizeof(int);
123
124	rcBSD = sysctlbyname("vfs.aio.max_aio_per_proc", /* name */
125	&cReqsOutstandingMax, /* Where to store the old value. */
126	&cbParameter, /* Size of the memory pointed to. */
127	NULL, /* Where the new value is located. */
128	0); /* Where the size of the new value is stored. */
129	if (rcBSD == -1)
130	{
131	/* ENOENT means the value is unknown thus the module is not loaded. */
132	if (errno == ENOENT)
133	return VERR_NOT_SUPPORTED;
134	else
135	return RTErrConvertFromErrno(errno);
136	}
137
138	pAioLimits->cReqsOutstandingMax = cReqsOutstandingMax;
139	pAioLimits->cbBufferAlignment = 0;
140
141	return VINF_SUCCESS;
142	}
143
144	RTR3DECL(int) RTFileAioReqCreate(PRTFILEAIOREQ phReq)
145	{
146	AssertPtrReturn(phReq, VERR_INVALID_POINTER);
147
148	PRTFILEAIOREQINTERNAL pReqInt = (PRTFILEAIOREQINTERNAL)RTMemAllocZ(sizeof(RTFILEAIOREQINTERNAL));
149	if (RT_UNLIKELY(!pReqInt))
150	return VERR_NO_MEMORY;
151
152	/* Ininitialize static parts. */
153	pReqInt->AioCB.aio_sigevent.sigev_notify = SIGEV_KEVENT;
154	pReqInt->AioCB.aio_sigevent.sigev_value.sival_ptr = pReqInt;
155	pReqInt->pCtxInt = NULL;
156	pReqInt->u32Magic = RTFILEAIOREQ_MAGIC;
157	RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
158
159	*phReq = (RTFILEAIOREQ)pReqInt;
160
161	return VINF_SUCCESS;
162	}
163
164	RTDECL(int) RTFileAioReqDestroy(RTFILEAIOREQ hReq)
165	{
166	/*
167	* Validate the handle and ignore nil.
168	*/
169	if (hReq == NIL_RTFILEAIOREQ)
170	return VINF_SUCCESS;
171	PRTFILEAIOREQINTERNAL pReqInt = hReq;
172	RTFILEAIOREQ_VALID_RETURN(pReqInt);
173	RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS);
174
175	/*
176	* Trash the magic and free it.
177	*/
178	ASMAtomicUoWriteU32(&pReqInt->u32Magic, ~RTFILEAIOREQ_MAGIC);
179	RTMemFree(pReqInt);
180	return VINF_SUCCESS;
181	}
182
183	/**
184	* Worker setting up the request.
185	*/
186	DECLINLINE(int) rtFileAioReqPrepareTransfer(RTFILEAIOREQ hReq, RTFILE hFile,
187	unsigned uTransferDirection,
188	RTFOFF off, void *pvBuf, size_t cbTransfer,
189	void *pvUser)
190	{
191	/*
192	* Validate the input.
193	*/
194	PRTFILEAIOREQINTERNAL pReqInt = hReq;
195	RTFILEAIOREQ_VALID_RETURN(pReqInt);
196	RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS);
197	Assert(hFile != NIL_RTFILE);
198	AssertPtr(pvBuf);
199	Assert(off >= 0);
200	Assert(cbTransfer > 0);
201
202	pReqInt->AioCB.aio_sigevent.sigev_notify = SIGEV_KEVENT;
203	pReqInt->AioCB.aio_sigevent.sigev_value.sival_ptr = pReqInt;
204	pReqInt->AioCB.aio_lio_opcode = uTransferDirection;
205	pReqInt->AioCB.aio_fildes = RTFileToNative(hFile);
206	pReqInt->AioCB.aio_offset = off;
207	pReqInt->AioCB.aio_nbytes = cbTransfer;
208	pReqInt->AioCB.aio_buf = pvBuf;
209	pReqInt->fFlush = false;
210	pReqInt->pvUser = pvUser;
211	pReqInt->pCtxInt = NULL;
212	pReqInt->Rc = VERR_FILE_AIO_IN_PROGRESS;
213	RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
214
215	return VINF_SUCCESS;
216	}
217
218	RTDECL(int) RTFileAioReqPrepareRead(RTFILEAIOREQ hReq, RTFILE hFile, RTFOFF off,
219	void pvBuf, size_t cbRead, void pvUser)
220	{
221	return rtFileAioReqPrepareTransfer(hReq, hFile, LIO_READ,
222	off, pvBuf, cbRead, pvUser);
223	}
224
225	RTDECL(int) RTFileAioReqPrepareWrite(RTFILEAIOREQ hReq, RTFILE hFile, RTFOFF off,
226	void const pvBuf, size_t cbWrite, void pvUser)
227	{
228	return rtFileAioReqPrepareTransfer(hReq, hFile, LIO_WRITE,
229	off, (void *)pvBuf, cbWrite, pvUser);
230	}
231
232	RTDECL(int) RTFileAioReqPrepareFlush(RTFILEAIOREQ hReq, RTFILE hFile, void *pvUser)
233	{
234	PRTFILEAIOREQINTERNAL pReqInt = (PRTFILEAIOREQINTERNAL)hReq;
235
236	RTFILEAIOREQ_VALID_RETURN(pReqInt);
237	Assert(hFile != NIL_RTFILE);
238	RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS);
239
240	pReqInt->fFlush = true;
241	pReqInt->AioCB.aio_fildes = RTFileToNative(hFile);
242	pReqInt->AioCB.aio_offset = 0;
243	pReqInt->AioCB.aio_nbytes = 0;
244	pReqInt->AioCB.aio_buf = NULL;
245	pReqInt->pvUser = pvUser;
246	RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
247
248	return VINF_SUCCESS;
249	}
250
251	RTDECL(void *) RTFileAioReqGetUser(RTFILEAIOREQ hReq)
252	{
253	PRTFILEAIOREQINTERNAL pReqInt = hReq;
254	RTFILEAIOREQ_VALID_RETURN_RC(pReqInt, NULL);
255
256	return pReqInt->pvUser;
257	}
258
259	RTDECL(int) RTFileAioReqCancel(RTFILEAIOREQ hReq)
260	{
261	PRTFILEAIOREQINTERNAL pReqInt = hReq;
262	RTFILEAIOREQ_VALID_RETURN(pReqInt);
263	RTFILEAIOREQ_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_NOT_SUBMITTED);
264
265
266	int rcBSD = aio_cancel(pReqInt->AioCB.aio_fildes, &pReqInt->AioCB);
267
268	if (rcBSD == AIO_CANCELED)
269	{
270	/*
271	* Decrement request count because the request will never arrive at the
272	* completion port.
273	*/
274	AssertMsg(VALID_PTR(pReqInt->pCtxInt),
275	("Invalid state. Request was canceled but wasn't submitted\n"));
276
277	ASMAtomicDecS32(&pReqInt->pCtxInt->cRequests);
278	pReqInt->Rc = VERR_FILE_AIO_CANCELED;
279	RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
280	return VINF_SUCCESS;
281	}
282	else if (rcBSD == AIO_ALLDONE)
283	return VERR_FILE_AIO_COMPLETED;
284	else if (rcBSD == AIO_NOTCANCELED)
285	return VERR_FILE_AIO_IN_PROGRESS;
286	else
287	return RTErrConvertFromErrno(errno);
288	}
289
290	RTDECL(int) RTFileAioReqGetRC(RTFILEAIOREQ hReq, size_t *pcbTransfered)
291	{
292	PRTFILEAIOREQINTERNAL pReqInt = hReq;
293	RTFILEAIOREQ_VALID_RETURN(pReqInt);
294	AssertPtrNull(pcbTransfered);
295	RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS);
296	RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, PREPARED, VERR_FILE_AIO_NOT_SUBMITTED);
297
298	if ( (RT_SUCCESS(pReqInt->Rc))
299	&& (pcbTransfered))
300	*pcbTransfered = pReqInt->cbTransfered;
301
302	return pReqInt->Rc;
303	}
304
305	RTDECL(int) RTFileAioCtxCreate(PRTFILEAIOCTX phAioCtx, uint32_t cAioReqsMax,
306	uint32_t fFlags)
307	{
308	int rc = VINF_SUCCESS;
309	PRTFILEAIOCTXINTERNAL pCtxInt;
310	AssertPtrReturn(phAioCtx, VERR_INVALID_POINTER);
311	AssertReturn(!(fFlags & ~RTFILEAIOCTX_FLAGS_VALID_MASK), VERR_INVALID_PARAMETER);
312
313	pCtxInt = (PRTFILEAIOCTXINTERNAL)RTMemAllocZ(sizeof(RTFILEAIOCTXINTERNAL));
314	if (RT_UNLIKELY(!pCtxInt))
315	return VERR_NO_MEMORY;
316
317	/* Init the event handle. */
318	pCtxInt->iKQueue = kqueue();
319	if (RT_LIKELY(pCtxInt->iKQueue > 0))
320	{
321	pCtxInt->fFlags = fFlags;
322	pCtxInt->u32Magic = RTFILEAIOCTX_MAGIC;
323	*phAioCtx = (RTFILEAIOCTX)pCtxInt;
324	}
325	else
326	{
327	RTMemFree(pCtxInt);
328	rc = RTErrConvertFromErrno(errno);
329	}
330
331	return rc;
332	}
333
334	RTDECL(int) RTFileAioCtxDestroy(RTFILEAIOCTX hAioCtx)
335	{
336	/* Validate the handle and ignore nil. */
337	if (hAioCtx == NIL_RTFILEAIOCTX)
338	return VINF_SUCCESS;
339	PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
340	RTFILEAIOCTX_VALID_RETURN(pCtxInt);
341
342	/* Cannot destroy a busy context. */
343	if (RT_UNLIKELY(pCtxInt->cRequests))
344	return VERR_FILE_AIO_BUSY;
345
346	close(pCtxInt->iKQueue);
347	ASMAtomicUoWriteU32(&pCtxInt->u32Magic, RTFILEAIOCTX_MAGIC_DEAD);
348	RTMemFree(pCtxInt);
349
350	return VINF_SUCCESS;
351	}
352
353	RTDECL(uint32_t) RTFileAioCtxGetMaxReqCount(RTFILEAIOCTX hAioCtx)
354	{
355	return RTFILEAIO_UNLIMITED_REQS;
356	}
357
358	RTDECL(int) RTFileAioCtxAssociateWithFile(RTFILEAIOCTX hAioCtx, RTFILE hFile)
359	{
360	return VINF_SUCCESS;
361	}
362
363	RTDECL(int) RTFileAioCtxSubmit(RTFILEAIOCTX hAioCtx, PRTFILEAIOREQ pahReqs, size_t cReqs)
364	{
365	/*
366	* Parameter validation.
367	*/
368	int rc = VINF_SUCCESS;
369	PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
370	RTFILEAIOCTX_VALID_RETURN(pCtxInt);
371	AssertReturn(cReqs > 0, VERR_INVALID_PARAMETER);
372	AssertPtrReturn(pahReqs, VERR_INVALID_POINTER);
373
374	do
375	{
376	int rcBSD = 0;
377	size_t cReqsSubmit = 0;
378	size_t i = 0;
379	PRTFILEAIOREQINTERNAL pReqInt;
380
381	while ( (i < cReqs)
382	&& (i < AIO_LISTIO_MAX))
383	{
384	pReqInt = pahReqs[i];
385	if (RTFILEAIOREQ_IS_NOT_VALID(pReqInt))
386	{
387	/* Undo everything and stop submitting. */
388	for (size_t iUndo = 0; iUndo < i; iUndo++)
389	{
390	pReqInt = pahReqs[iUndo];
391	RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
392	pReqInt->pCtxInt = NULL;
393	pReqInt->AioCB.aio_sigevent.sigev_notify_kqueue = 0;
394	}
395	rc = VERR_INVALID_HANDLE;
396	break;
397	}
398
399	pReqInt->AioCB.aio_sigevent.sigev_notify_kqueue = pCtxInt->iKQueue;
400	pReqInt->pCtxInt = pCtxInt;
401	RTFILEAIOREQ_SET_STATE(pReqInt, SUBMITTED);
402
403	if (pReqInt->fFlush)
404	break;
405
406	cReqsSubmit++;
407	i++;
408	}
409
410	if (cReqsSubmit)
411	{
412	rcBSD = lio_listio(LIO_NOWAIT, (struct aiocb **)pahReqs, cReqsSubmit, NULL);
413	if (RT_UNLIKELY(rcBSD < 0))
414	{
415	if (errno == EAGAIN)
416	rc = VERR_FILE_AIO_INSUFFICIENT_RESSOURCES;
417	else
418	rc = RTErrConvertFromErrno(errno);
419
420	/* Check which requests got actually submitted and which not. */
421	for (i = 0; i < cReqs; i++)
422	{
423	pReqInt = pahReqs[i];
424	rcBSD = aio_error(&pReqInt->AioCB);
425	if ( rcBSD == -1
426	&& errno == EINVAL)
427	{
428	/* Was not submitted. */
429	RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
430	pReqInt->pCtxInt = NULL;
431	}
432	else if (rcBSD != EINPROGRESS)
433	{
434	/* The request encountered an error. */
435	RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
436	pReqInt->Rc = RTErrConvertFromErrno(rcBSD);
437	pReqInt->pCtxInt = NULL;
438	pReqInt->cbTransfered = 0;
439	}
440	}
441	break;
442	}
443
444	ASMAtomicAddS32(&pCtxInt->cRequests, cReqsSubmit);
445	cReqs -= cReqsSubmit;
446	pahReqs += cReqsSubmit;
447	}
448
449	/* Check if we have a flush request now. */
450	if (cReqs && RT_SUCCESS_NP(rc))
451	{
452	pReqInt = pahReqs[0];
453	RTFILEAIOREQ_VALID_RETURN(pReqInt);
454
455	if (pReqInt->fFlush)
456	{
457	/*
458	* lio_listio does not work with flush requests so
459	* we have to use aio_fsync directly.
460	*/
461	rcBSD = aio_fsync(O_SYNC, &pReqInt->AioCB);
462	if (RT_UNLIKELY(rcBSD < 0))
463	{
464	if (rcBSD == EAGAIN)
465	{
466	/* Was not submitted. */
467	RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
468	pReqInt->pCtxInt = NULL;
469	return VERR_FILE_AIO_INSUFFICIENT_RESSOURCES;
470	}
471	else
472	{
473	RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
474	pReqInt->Rc = RTErrConvertFromErrno(errno);
475	pReqInt->cbTransfered = 0;
476	return pReqInt->Rc;
477	}
478	}
479
480	ASMAtomicIncS32(&pCtxInt->cRequests);
481	cReqs--;
482	pahReqs++;
483	}
484	}
485	} while (cReqs);
486
487	return rc;
488	}
489
490	RTDECL(int) RTFileAioCtxWait(RTFILEAIOCTX hAioCtx, size_t cMinReqs, RTMSINTERVAL cMillies,
491	PRTFILEAIOREQ pahReqs, size_t cReqs, uint32_t *pcReqs)
492	{
493	int rc = VINF_SUCCESS;
494	int cRequestsCompleted = 0;
495
496	/*
497	* Validate the parameters, making sure to always set pcReqs.
498	*/
499	AssertPtrReturn(pcReqs, VERR_INVALID_POINTER);
500	pcReqs = 0; / always set */
501	PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
502	RTFILEAIOCTX_VALID_RETURN(pCtxInt);
503	AssertPtrReturn(pahReqs, VERR_INVALID_POINTER);
504	AssertReturn(cReqs != 0, VERR_INVALID_PARAMETER);
505	AssertReturn(cReqs >= cMinReqs, VERR_OUT_OF_RANGE);
506
507	if ( RT_UNLIKELY(ASMAtomicReadS32(&pCtxInt->cRequests) == 0)
508	&& !(pCtxInt->fFlags & RTFILEAIOCTX_FLAGS_WAIT_WITHOUT_PENDING_REQUESTS))
509	return VERR_FILE_AIO_NO_REQUEST;
510
511	/*
512	* Convert the timeout if specified.
513	*/
514	struct timespec *pTimeout = NULL;
515	struct timespec Timeout = {0,0};
516	uint64_t StartNanoTS = 0;
517	if (cMillies != RT_INDEFINITE_WAIT)
518	{
519	Timeout.tv_sec = cMillies / 1000;
520	Timeout.tv_nsec = cMillies % 1000 * 1000000;
521	pTimeout = &Timeout;
522	StartNanoTS = RTTimeNanoTS();
523	}
524
525	/* Wait for at least one. */
526	if (!cMinReqs)
527	cMinReqs = 1;
528
529	/* For the wakeup call. */
530	Assert(pCtxInt->hThreadWait == NIL_RTTHREAD);
531	ASMAtomicWriteHandle(&pCtxInt->hThreadWait, RTThreadSelf());
532
533	while ( cMinReqs
534	&& RT_SUCCESS_NP(rc))
535	{
536	struct kevent aKEvents[AIO_MAXIMUM_REQUESTS_PER_CONTEXT];
537	int cRequestsToWait = cMinReqs < AIO_MAXIMUM_REQUESTS_PER_CONTEXT ? cReqs : AIO_MAXIMUM_REQUESTS_PER_CONTEXT;
538	int rcBSD;
539	uint64_t StartTime;
540
541	ASMAtomicXchgBool(&pCtxInt->fWaiting, true);
542	rcBSD = kevent(pCtxInt->iKQueue, NULL, 0, aKEvents, cRequestsToWait, pTimeout);
543	ASMAtomicXchgBool(&pCtxInt->fWaiting, false);
544
545	if (RT_UNLIKELY(rcBSD < 0))
546	{
547	rc = RTErrConvertFromErrno(errno);
548	break;
549	}
550
551	uint32_t const cDone = rcBSD;
552
553	/* Process received events. */
554	for (uint32_t i = 0; i < cDone; i++)
555	{
556	PRTFILEAIOREQINTERNAL pReqInt = (PRTFILEAIOREQINTERNAL)aKEvents[i].udata;
557	AssertPtr(pReqInt);
558	Assert(pReqInt->u32Magic == RTFILEAIOREQ_MAGIC);
559
560	/*
561	* Retrieve the status code here already because the
562	* user may omit the RTFileAioReqGetRC() call and
563	* we will leak kernel resources then.
564	* This will result in errors during submission
565	* of other requests as soon as the max_aio_queue_per_proc
566	* limit is reached.
567	*/
568	int cbTransfered = aio_return(&pReqInt->AioCB);
569
570	if (cbTransfered < 0)
571	{
572	pReqInt->Rc = RTErrConvertFromErrno(cbTransfered);
573	pReqInt->cbTransfered = 0;
574	}
575	else
576	{
577	pReqInt->Rc = VINF_SUCCESS;
578	pReqInt->cbTransfered = cbTransfered;
579	}
580	RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
581	pahReqs[cRequestsCompleted++] = (RTFILEAIOREQ)pReqInt;
582	}
583
584	/*
585	* Done Yet? If not advance and try again.
586	*/
587	if (cDone >= cMinReqs)
588	break;
589	cMinReqs -= cDone;
590	cReqs -= cDone;
591
592	if (cMillies != RT_INDEFINITE_WAIT)
593	{
594	/* The API doesn't return ETIMEDOUT, so we have to fix that ourselves. */
595	uint64_t NanoTS = RTTimeNanoTS();
596	uint64_t cMilliesElapsed = (NanoTS - StartNanoTS) / 1000000;
597	if (cMilliesElapsed >= cMillies)
598	{
599	rc = VERR_TIMEOUT;
600	break;
601	}
602
603	/* The syscall supposedly updates it, but we're paranoid. :-) */
604	Timeout.tv_sec = (cMillies - (RTMSINTERVAL)cMilliesElapsed) / 1000;
605	Timeout.tv_nsec = (cMillies - (RTMSINTERVAL)cMilliesElapsed) % 1000 * 1000000;
606	}
607	}
608
609	/*
610	* Update the context state and set the return value.
611	*/
612	*pcReqs = cRequestsCompleted;
613	ASMAtomicSubS32(&pCtxInt->cRequests, cRequestsCompleted);
614	Assert(pCtxInt->hThreadWait == RTThreadSelf());
615	ASMAtomicWriteHandle(&pCtxInt->hThreadWait, NIL_RTTHREAD);
616
617	/*
618	* Clear the wakeup flag and set rc.
619	*/
620	if ( pCtxInt->fWokenUp
621	&& RT_SUCCESS(rc))
622	{
623	ASMAtomicXchgBool(&pCtxInt->fWokenUp, false);
624	rc = VERR_INTERRUPTED;
625	}
626
627	return rc;
628	}
629
630	RTDECL(int) RTFileAioCtxWakeup(RTFILEAIOCTX hAioCtx)
631	{
632	PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
633	RTFILEAIOCTX_VALID_RETURN(pCtxInt);
634
635	/** @todo r=bird: Define the protocol for how to resume work after calling
636	* this function. */
637
638	bool fWokenUp = ASMAtomicXchgBool(&pCtxInt->fWokenUp, true);
639
640	/*
641	* Read the thread handle before the status flag.
642	* If we read the handle after the flag we might
643	* end up with an invalid handle because the thread
644	* waiting in RTFileAioCtxWakeup() might get scheduled
645	* before we read the flag and returns.
646	* We can ensure that the handle is valid if fWaiting is true
647	* when reading the handle before the status flag.
648	*/
649	RTTHREAD hThread;
650	ASMAtomicReadHandle(&pCtxInt->hThreadWait, &hThread);
651	bool fWaiting = ASMAtomicReadBool(&pCtxInt->fWaiting);
652	if ( !fWokenUp
653	&& fWaiting)
654	{
655	/*
656	* If a thread waits the handle must be valid.
657	* It is possible that the thread returns from
658	* kevent() before the signal is send.
659	* This is no problem because we already set fWokenUp
660	* to true which will let the thread return VERR_INTERRUPTED
661	* and the next call to RTFileAioCtxWait() will not
662	* return VERR_INTERRUPTED because signals are not saved
663	* and will simply vanish if the destination thread can't
664	* receive it.
665	*/
666	Assert(hThread != NIL_RTTHREAD);
667	RTThreadPoke(hThread);
668	}
669
670	return VINF_SUCCESS;
671	}
672

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

source: vbox/trunk/src/VBox/Runtime/r3/freebsd/fileaio-freebsd.cpp@ 57358

Download in other formats: