fileaio-freebsd.cpp

Last change on this file was 106061, checked in by vboxsync, 2 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 22.8 KB

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

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

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

Download in other formats: