fileaio-linux.cpp@ 19948

Last change on this file since 19948 was 19562, checked in by vboxsync, 15 years ago

Runtime/Aio: Change API again

pcReqs in RTFileAioCtxSubmit is useless because it does not specify which request fails. Removed it again and made it possible to get the state of a request through RTFileAioReqGetRC()
Introduce request states for the first point and to catch more errors using the API before a system dependent call is made to return the same error codes one every system for the same cause.
Add RTFileAioGetLimits to get global limits and indication for AIO support.
General cleanups and fixes

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

File size: 25.9 KB

Line
1	/* $Id: fileaio-linux.cpp 19562 2009-05-10 21:44:16Z vboxsync $ */
2	/** @file
3	* IPRT - File async I/O, native implementation for the Linux host platform.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 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	/** @page pg_rtfileaio_linux RTFile Async I/O - Linux Implementation Notes
32	* @internal
33	*
34	* Linux implements the kernel async I/O API through the io_* syscalls. They are
35	* not exposed in the glibc (the aio_* API uses userspace threads and blocking
36	* I/O operations to simulate async behavior). There is an external library
37	* called libaio which implements these syscalls but because we don't want to
38	* have another dependency and this library is not installed by default and the
39	* interface is really simple we use the kernel interface directly using wrapper
40	* functions.
41	*
42	* The interface has some limitations. The first one is that the file must be
43	* opened with O_DIRECT. This disables caching done by the kernel which can be
44	* compensated if the user of this API implements caching itself. The next
45	* limitation is that data buffers must be aligned at a 512 byte boundary or the
46	* request will fail.
47	*/
48	/** @todo r=bird: What's this about "must be opened with O_DIRECT"? An
49	* explanation would be nice, esp. seeing what Linus is quoted saying
50	* about it in the open man page... */
51
52	/*******************************************************************************
53	* Header Files *
54	*******************************************************************************/
55	#define LOG_GROUP RTLOGGROUP_FILE
56	#include <iprt/asm.h>
57	#include <iprt/mem.h>
58	#include <iprt/assert.h>
59	#include <iprt/string.h>
60	#include <iprt/err.h>
61	#include <iprt/log.h>
62	#include <iprt/thread.h>
63	#include "internal/fileaio.h"
64
65	#define _LINUX_BYTEORDER_SWABB_H
66	#include <linux/aio_abi.h>
67	#include <unistd.h>
68	#include <sys/syscall.h>
69	#include <errno.h>
70
71	#include <iprt/file.h>
72
73
74	/*******************************************************************************
75	* Structures and Typedefs *
76	*******************************************************************************/
77	/**
78	* The iocb structure of a request which is passed to the kernel.
79	*
80	* We redefined this here because the version in the header lacks padding
81	* for 32bit.
82	*/
83	typedef struct LNXKAIOIOCB
84	{
85	/** Opaque pointer to data which is returned on an I/O event. */
86	void *pvUser;
87	#ifdef RT_ARCH_X86
88	uint32_t u32Padding0;
89	#endif
90	/** Contains the request number and is set by the kernel. */
91	uint32_t u32Key;
92	/** Reserved. */
93	uint32_t u32Reserved0;
94	/** The I/O opcode. */
95	uint16_t u16IoOpCode;
96	/** Request priority. */
97	int16_t i16Priority;
98	/** The file descriptor. */
99	uint32_t File;
100	/** The userspace pointer to the buffer containing/receiving the data. */
101	void *pvBuf;
102	#ifdef RT_ARCH_X86
103	uint32_t u32Padding1;
104	#endif
105	/** How many bytes to transfer. */
106	#ifdef RT_ARCH_X86
107	uint32_t cbTransfer;
108	uint32_t u32Padding2;
109	#elif defined(RT_ARCH_AMD64)
110	uint64_t cbTransfer;
111	#else
112	# error "Unknown architecture"
113	#endif
114	/** At which offset to start the transfer. */
115	int64_t off;
116	/** Reserved. */
117	uint64_t u64Reserved1;
118	/** Flags */
119	uint32_t fFlags;
120	/** Readyness signal file descriptor. */
121	uint32_t u32ResFd;
122	} LNXKAIOIOCB, *PLNXKAIOIOCB;
123
124	/**
125	* I/O event structure to notify about completed requests.
126	* Redefined here too because of the padding.
127	*/
128	typedef struct LNXKAIOIOEVENT
129	{
130	/** The pvUser field from the iocb. */
131	void *pvUser;
132	#ifdef RT_ARCH_X86
133	uint32_t u32Padding0;
134	#endif
135	/** The LNXKAIOIOCB object this event is for. */
136	PLNXKAIOIOCB *pIoCB;
137	#ifdef RT_ARCH_X86
138	uint32_t u32Padding1;
139	#endif
140	/** The result code of the operation .*/
141	#ifdef RT_ARCH_X86
142	int32_t rc;
143	uint32_t u32Padding2;
144	#elif defined(RT_ARCH_AMD64)
145	int64_t rc;
146	#else
147	# error "Unknown architecture"
148	#endif
149	/** Secondary result code. */
150	#ifdef RT_ARCH_X86
151	int32_t rc2;
152	uint32_t u32Padding3;
153	#elif defined(RT_ARCH_AMD64)
154	int64_t rc2;
155	#else
156	# error "Unknown architecture"
157	#endif
158	} LNXKAIOIOEVENT, *PLNXKAIOIOEVENT;
159
160
161	/**
162	* Async I/O completion context state.
163	*/
164	typedef struct RTFILEAIOCTXINTERNAL
165	{
166	/** Handle to the async I/O context. */
167	aio_context_t AioContext;
168	/** Maximum number of requests this context can handle. */
169	int cRequestsMax;
170	/** Current number of requests active on this context. */
171	volatile int32_t cRequests;
172	/** The ID of the thread which is currently waiting for requests. */
173	volatile RTTHREAD hThreadWait;
174	/** Flag whether the thread was woken up. */
175	volatile bool fWokenUp;
176	/** Flag whether the thread is currently waiting in the syscall. */
177	volatile bool fWaiting;
178	/** Magic value (RTFILEAIOCTX_MAGIC). */
179	uint32_t u32Magic;
180	} RTFILEAIOCTXINTERNAL;
181	/** Pointer to an internal context structure. */
182	typedef RTFILEAIOCTXINTERNAL *PRTFILEAIOCTXINTERNAL;
183
184	/**
185	* Async I/O request state.
186	*/
187	typedef struct RTFILEAIOREQINTERNAL
188	{
189	/** The aio control block. This must be the FIRST elment in
190	* the structure! (see notes below) */
191	LNXKAIOIOCB AioCB;
192	/** Current state the request is in. */
193	RTFILEAIOREQSTATE enmState;
194	/** The I/O context this request is associated with. */
195	aio_context_t AioContext;
196	/** Return code the request completed with. */
197	int Rc;
198	/** Number of bytes actually trasnfered. */
199	size_t cbTransfered;
200	/** Completion context we are assigned to. */
201	PRTFILEAIOCTXINTERNAL pCtxInt;
202	/** Magic value (RTFILEAIOREQ_MAGIC). */
203	uint32_t u32Magic;
204	} RTFILEAIOREQINTERNAL;
205	/** Pointer to an internal request structure. */
206	typedef RTFILEAIOREQINTERNAL *PRTFILEAIOREQINTERNAL;
207
208
209	/*******************************************************************************
210	* Defined Constants And Macros *
211	*******************************************************************************/
212	/** The max number of events to get in one call. */
213	#define AIO_MAXIMUM_REQUESTS_PER_CONTEXT 64
214
215
216	/**
217	* Creates a new async I/O context.
218	*/
219	DECLINLINE(int) rtFileAsyncIoLinuxCreate(unsigned cEvents, aio_context_t *pAioContext)
220	{
221	int rc = syscall(__NR_io_setup, cEvents, pAioContext);
222	if (RT_UNLIKELY(rc == -1))
223	return RTErrConvertFromErrno(errno);
224
225	return VINF_SUCCESS;
226	}
227
228	/**
229	* Destroys a async I/O context.
230	*/
231	DECLINLINE(int) rtFileAsyncIoLinuxDestroy(aio_context_t AioContext)
232	{
233	int rc = syscall(__NR_io_destroy, AioContext);
234	if (RT_UNLIKELY(rc == -1))
235	return RTErrConvertFromErrno(errno);
236
237	return VINF_SUCCESS;
238	}
239
240	/**
241	* Submits an array of I/O requests to the kernel.
242	*/
243	DECLINLINE(int) rtFileAsyncIoLinuxSubmit(aio_context_t AioContext, long cReqs, LNXKAIOIOCB *ppIoCB, int pcSubmitted)
244	{
245	int rc = syscall(__NR_io_submit, AioContext, cReqs, ppIoCB);
246	if (RT_UNLIKELY(rc == -1))
247	return RTErrConvertFromErrno(errno);
248
249	*pcSubmitted = rc;
250
251	return VINF_SUCCESS;
252	}
253
254	/**
255	* Cancels a I/O request.
256	*/
257	DECLINLINE(int) rtFileAsyncIoLinuxCancel(aio_context_t AioContext, PLNXKAIOIOCB pIoCB, PLNXKAIOIOEVENT pIoResult)
258	{
259	int rc = syscall(__NR_io_cancel, AioContext, pIoCB, pIoResult);
260	if (RT_UNLIKELY(rc == -1))
261	return RTErrConvertFromErrno(errno);
262
263	return VINF_SUCCESS;
264	}
265
266	/**
267	* Waits for I/O events.
268	* @returns Number of events (natural number w/ 0), IPRT error code (negative).
269	*/
270	DECLINLINE(int) rtFileAsyncIoLinuxGetEvents(aio_context_t AioContext, long cReqsMin, long cReqs,
271	PLNXKAIOIOEVENT paIoResults, struct timespec *pTimeout)
272	{
273	int rc = syscall(__NR_io_getevents, AioContext, cReqsMin, cReqs, paIoResults, pTimeout);
274	if (RT_UNLIKELY(rc == -1))
275	return RTErrConvertFromErrno(errno);
276
277	return rc;
278	}
279
280	RTR3DECL(int) RTFileAioGetLimits(PRTFILEAIOLIMITS pAioLimits)
281	{
282	int rc = VINF_SUCCESS;
283	AssertPtrReturn(pAioLimits, VERR_INVALID_POINTER);
284
285	/*
286	* Check if the API is implemented by creating a
287	* completion port.
288	*/
289	aio_context_t AioContext = 0;
290	rc = rtFileAsyncIoLinuxCreate(1, &AioContext);
291	if (RT_FAILURE(rc))
292	return rc;
293
294	rc = rtFileAsyncIoLinuxDestroy(AioContext);
295	if (RT_FAILURE(rc))
296	return rc;
297
298	/* Supported - fill in the limits. The alignment is the only restriction. */
299	pAioLimits->cReqsOutstandingMax = RTFILEAIO_UNLIMITED_REQS;
300	pAioLimits->cbBufferAlignment = 512;
301
302	return VINF_SUCCESS;
303	}
304
305
306	RTR3DECL(int) RTFileAioReqCreate(PRTFILEAIOREQ phReq)
307	{
308	AssertPtrReturn(phReq, VERR_INVALID_POINTER);
309
310	/*
311	* Allocate a new request and initialize it.
312	*/
313	PRTFILEAIOREQINTERNAL pReqInt = (PRTFILEAIOREQINTERNAL)RTMemAllocZ(sizeof(*pReqInt));
314	if (RT_UNLIKELY(!pReqInt))
315	return VERR_NO_MEMORY;
316
317	pReqInt->pCtxInt = NULL;
318	pReqInt->u32Magic = RTFILEAIOREQ_MAGIC;
319	RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
320
321	*phReq = (RTFILEAIOREQ)pReqInt;
322	return VINF_SUCCESS;
323	}
324
325
326	RTDECL(int) RTFileAioReqDestroy(RTFILEAIOREQ hReq)
327	{
328	/*
329	* Validate the handle and ignore nil.
330	*/
331	if (hReq == NIL_RTFILEAIOREQ)
332	return VINF_SUCCESS;
333	PRTFILEAIOREQINTERNAL pReqInt = hReq;
334	RTFILEAIOREQ_VALID_RETURN(pReqInt);
335	RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS);
336
337	/*
338	* Trash the magic and free it.
339	*/
340	ASMAtomicUoWriteU32(&pReqInt->u32Magic, ~RTFILEAIOREQ_MAGIC);
341	RTMemFree(pReqInt);
342	return VINF_SUCCESS;
343	}
344
345
346	/**
347	* Worker setting up the request.
348	*/
349	DECLINLINE(int) rtFileAioReqPrepareTransfer(RTFILEAIOREQ hReq, RTFILE hFile,
350	uint16_t uTransferDirection,
351	RTFOFF off, void *pvBuf, size_t cbTransfer,
352	void *pvUser)
353	{
354	/*
355	* Validate the input.
356	*/
357	PRTFILEAIOREQINTERNAL pReqInt = hReq;
358	RTFILEAIOREQ_VALID_RETURN(pReqInt);
359	RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS);
360	Assert(hFile != NIL_RTFILE);
361	AssertPtr(pvBuf);
362	Assert(off >= 0);
363	Assert(cbTransfer > 0);
364
365	/*
366	* Setup the control block and clear the finished flag.
367	*/
368	pReqInt->AioCB.u16IoOpCode = uTransferDirection;
369	pReqInt->AioCB.File = (uint32_t)hFile;
370	pReqInt->AioCB.off = off;
371	pReqInt->AioCB.cbTransfer = cbTransfer;
372	pReqInt->AioCB.pvBuf = pvBuf;
373	pReqInt->AioCB.pvUser = pvUser;
374
375	pReqInt->pCtxInt = NULL;
376	RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
377
378	return VINF_SUCCESS;
379	}
380
381
382	RTDECL(int) RTFileAioReqPrepareRead(RTFILEAIOREQ hReq, RTFILE hFile, RTFOFF off,
383	void pvBuf, size_t cbRead, void pvUser)
384	{
385	return rtFileAioReqPrepareTransfer(hReq, hFile, IOCB_CMD_PREAD,
386	off, pvBuf, cbRead, pvUser);
387	}
388
389
390	RTDECL(int) RTFileAioReqPrepareWrite(RTFILEAIOREQ hReq, RTFILE hFile, RTFOFF off,
391	void pvBuf, size_t cbWrite, void pvUser)
392	{
393	return rtFileAioReqPrepareTransfer(hReq, hFile, IOCB_CMD_PWRITE,
394	off, pvBuf, cbWrite, pvUser);
395	}
396
397
398	RTDECL(int) RTFileAioReqPrepareFlush(RTFILEAIOREQ hReq, RTFILE hFile, void *pvUser)
399	{
400	PRTFILEAIOREQINTERNAL pReqInt = hReq;
401	RTFILEAIOREQ_VALID_RETURN(pReqInt);
402	AssertReturn(hFile != NIL_RTFILE, VERR_INVALID_HANDLE);
403	RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS);
404
405	/** @todo: Flushing is not neccessary on Linux because O_DIRECT is mandatory
406	* which disables caching.
407	* We could setup a fake request which isn't really executed
408	* to avoid platform dependent code in the caller.
409	*/
410	#if 0
411	return rtFileAsyncPrepareTransfer(pRequest, File, TRANSFERDIRECTION_FLUSH,
412	0, NULL, 0, pvUser);
413	#endif
414	return VERR_NOT_IMPLEMENTED;
415	}
416
417
418	RTDECL(void *) RTFileAioReqGetUser(RTFILEAIOREQ hReq)
419	{
420	PRTFILEAIOREQINTERNAL pReqInt = hReq;
421	RTFILEAIOREQ_VALID_RETURN_RC(pReqInt, NULL);
422
423	return pReqInt->AioCB.pvUser;
424	}
425
426
427	RTDECL(int) RTFileAioReqCancel(RTFILEAIOREQ hReq)
428	{
429	PRTFILEAIOREQINTERNAL pReqInt = hReq;
430	RTFILEAIOREQ_VALID_RETURN(pReqInt);
431	RTFILEAIOREQ_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_NOT_SUBMITTED);
432
433	LNXKAIOIOEVENT AioEvent;
434	int rc = rtFileAsyncIoLinuxCancel(pReqInt->AioContext, &pReqInt->AioCB, &AioEvent);
435	if (RT_SUCCESS(rc))
436	{
437	/*
438	* Decrement request count because the request will never arrive at the
439	* completion port.
440	*/
441	AssertMsg(VALID_PTR(pReqInt->pCtxInt),
442	("Invalid state. Request was canceled but wasn't submitted\n"));
443
444	ASMAtomicDecS32(&pReqInt->pCtxInt->cRequests);
445	pReqInt->Rc = VERR_FILE_AIO_CANCELED;
446	RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
447	return VINF_SUCCESS;
448	}
449	if (rc == VERR_TRY_AGAIN)
450	return VERR_FILE_AIO_IN_PROGRESS;
451	return rc;
452	}
453
454
455	RTDECL(int) RTFileAioReqGetRC(RTFILEAIOREQ hReq, size_t *pcbTransfered)
456	{
457	PRTFILEAIOREQINTERNAL pReqInt = hReq;
458	RTFILEAIOREQ_VALID_RETURN(pReqInt);
459	AssertPtrNull(pcbTransfered);
460	RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS);
461	RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, PREPARED, VERR_FILE_AIO_NOT_SUBMITTED);
462
463	if ( pcbTransfered
464	&& RT_SUCCESS(pReqInt->Rc))
465	*pcbTransfered = pReqInt->cbTransfered;
466
467	return pReqInt->Rc;
468	}
469
470
471	RTDECL(int) RTFileAioCtxCreate(PRTFILEAIOCTX phAioCtx, uint32_t cAioReqsMax)
472	{
473	PRTFILEAIOCTXINTERNAL pCtxInt;
474	AssertPtrReturn(phAioCtx, VERR_INVALID_POINTER);
475
476	/* The kernel interface needs a maximum. */
477	if (cAioReqsMax == RTFILEAIO_UNLIMITED_REQS)
478	return VERR_OUT_OF_RANGE;
479
480	pCtxInt = (PRTFILEAIOCTXINTERNAL)RTMemAllocZ(sizeof(RTFILEAIOCTXINTERNAL));
481	if (RT_UNLIKELY(!pCtxInt))
482	return VERR_NO_MEMORY;
483
484	/* Init the event handle. */
485	int rc = rtFileAsyncIoLinuxCreate(cAioReqsMax, &pCtxInt->AioContext);
486	if (RT_SUCCESS(rc))
487	{
488	pCtxInt->fWokenUp = false;
489	pCtxInt->fWaiting = false;
490	pCtxInt->hThreadWait = NIL_RTTHREAD;
491	pCtxInt->cRequestsMax = cAioReqsMax;
492	pCtxInt->u32Magic = RTFILEAIOCTX_MAGIC;
493	*phAioCtx = (RTFILEAIOCTX)pCtxInt;
494	}
495	else
496	RTMemFree(pCtxInt);
497
498	return rc;
499	}
500
501
502	RTDECL(int) RTFileAioCtxDestroy(RTFILEAIOCTX hAioCtx)
503	{
504	/* Validate the handle and ignore nil. */
505	if (hAioCtx == NIL_RTFILEAIOCTX)
506	return VINF_SUCCESS;
507	PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
508	RTFILEAIOCTX_VALID_RETURN(pCtxInt);
509
510	/* Cannot destroy a busy context. */
511	if (RT_UNLIKELY(pCtxInt->cRequests))
512	return VERR_FILE_AIO_BUSY;
513
514	/* The native bit first, then mark it as dead and free it. */
515	int rc = rtFileAsyncIoLinuxDestroy(pCtxInt->AioContext);
516	if (RT_FAILURE(rc))
517	return rc;
518	ASMAtomicUoWriteU32(&pCtxInt->u32Magic, RTFILEAIOCTX_MAGIC_DEAD);
519	RTMemFree(pCtxInt);
520
521	return VINF_SUCCESS;
522	}
523
524
525	RTDECL(uint32_t) RTFileAioCtxGetMaxReqCount(RTFILEAIOCTX hAioCtx)
526	{
527	/* Nil means global here. */
528	if (hAioCtx == NIL_RTFILEAIOCTX)
529	return RTFILEAIO_UNLIMITED_REQS; /** @todo r=bird: I'm a bit puzzled by this return value since it
530	* is completely useless in RTFileAioCtxCreate. */
531
532	/* Return 0 if the handle is invalid, it's better than garbage I think... */
533	PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
534	RTFILEAIOCTX_VALID_RETURN_RC(pCtxInt, 0);
535
536	return pCtxInt->cRequestsMax;
537	}
538
539	RTDECL(int) RTFileAioCtxAssociateWithFile(RTFILEAIOCTX hAioCtx, RTFILE hFile)
540	{
541	/* Nothing to do. */
542	return VINF_SUCCESS;
543	}
544
545	RTDECL(int) RTFileAioCtxSubmit(RTFILEAIOCTX hAioCtx, PRTFILEAIOREQ pahReqs, size_t cReqs)
546	{
547	int rc = VINF_SUCCESS;
548
549	/*
550	* Parameter validation.
551	*/
552	PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
553	RTFILEAIOCTX_VALID_RETURN(pCtxInt);
554	AssertReturn(cReqs > 0, VERR_INVALID_PARAMETER);
555	AssertPtrReturn(pahReqs, VERR_INVALID_POINTER);
556	uint32_t i = cReqs;
557	PRTFILEAIOREQINTERNAL pReqInt = NULL;
558
559	/*
560	* Vaildate requests and associate with the context.
561	*/
562	while (i-- > 0)
563	{
564	pReqInt = pahReqs[i];
565	if (RTFILEAIOREQ_IS_NOT_VALID(pReqInt))
566	{
567	/* Undo everything and stop submitting. */
568	size_t iUndo = cReqs;
569	while (iUndo-- > i)
570	{
571	pReqInt = pahReqs[iUndo];
572	RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
573	pReqInt->pCtxInt = NULL;
574	}
575	return VERR_INVALID_HANDLE;
576	}
577
578	pReqInt->AioContext = pCtxInt->AioContext;
579	pReqInt->pCtxInt = pCtxInt;
580	RTFILEAIOREQ_SET_STATE(pReqInt, SUBMITTED);
581	}
582
583	do
584	{
585	/*
586	* We cast pahReqs to the Linux iocb structure to avoid copying the requests
587	* into a temporary array. This is possible because the iocb structure is
588	* the first element in the request structure (see PRTFILEAIOCTXINTERNAL).
589	*/
590	int cReqsSubmitted = 0;
591	rc = rtFileAsyncIoLinuxSubmit(pCtxInt->AioContext, cReqs,
592	(PLNXKAIOIOCB *)pahReqs,
593	&cReqsSubmitted);
594	if (RT_FAILURE(rc))
595	{
596	/*
597	* We encountered an error.
598	* This means that the first IoCB
599	* is not correctly initialized
600	* (invalid buffer alignment or bad file descriptor).
601	* Revert every request into the prepared state except
602	* the first one which will switch to completed.
603	* Another reason could be insuffidient ressources.
604	*/
605	i = cReqs;
606	while (i-- > 0)
607	{
608	/* Already validated. */
609	pReqInt = pahReqs[i];
610	pReqInt->pCtxInt = NULL;
611	pReqInt->AioContext = 0;
612	RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
613	}
614
615	if (rc == VERR_TRY_AGAIN)
616	return VERR_FILE_AIO_INSUFFICIENT_RESSOURCES;
617	else
618	{
619	/* The first request failed. */
620	pReqInt = pahReqs[0];
621	RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
622	pReqInt->Rc = rc;
623	pReqInt->cbTransfered = 0;
624	return rc;
625	}
626	}
627
628	/* Advance. */
629	cReqs -= cReqsSubmitted;
630	pahReqs += cReqsSubmitted;
631	ASMAtomicAddS32(&pCtxInt->cRequests, cReqsSubmitted);
632
633	} while (cReqs);
634
635	return rc;
636	}
637
638
639	RTDECL(int) RTFileAioCtxWait(RTFILEAIOCTX hAioCtx, size_t cMinReqs, unsigned cMillisTimeout,
640	PRTFILEAIOREQ pahReqs, size_t cReqs, uint32_t *pcReqs)
641	{
642	/*
643	* Validate the parameters, making sure to always set pcReqs.
644	*/
645	AssertPtrReturn(pcReqs, VERR_INVALID_POINTER);
646	pcReqs = 0; / always set */
647	PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
648	RTFILEAIOCTX_VALID_RETURN(pCtxInt);
649	AssertPtrReturn(pahReqs, VERR_INVALID_POINTER);
650	AssertReturn(cReqs != 0, VERR_INVALID_PARAMETER);
651	AssertReturn(cReqs >= cMinReqs, VERR_OUT_OF_RANGE);
652
653	/*
654	* Can't wait if there are not requests around.
655	*/
656	if (RT_UNLIKELY(ASMAtomicUoReadS32(&pCtxInt->cRequests) == 0))
657	return VERR_FILE_AIO_NO_REQUEST;
658
659	/*
660	* Convert the timeout if specified.
661	*/
662	struct timespec *pTimeout = NULL;
663	struct timespec Timeout = {0,0};
664	uint64_t StartNanoTS = 0;
665	if (cMillisTimeout != RT_INDEFINITE_WAIT)
666	{
667	Timeout.tv_sec = cMillisTimeout / 1000;
668	Timeout.tv_nsec = cMillisTimeout % 1000 * 1000000;
669	pTimeout = &Timeout;
670	StartNanoTS = RTTimeNanoTS();
671	}
672
673	/* Wait for at least one. */
674	if (!cMinReqs)
675	cMinReqs = 1;
676
677	/* For the wakeup call. */
678	Assert(pCtxInt->hThreadWait == NIL_RTTHREAD);
679	ASMAtomicWriteHandle(&pCtxInt->hThreadWait, RTThreadSelf());
680
681	/*
682	* Loop until we're woken up, hit an error (incl timeout), or
683	* have collected the desired number of requests.
684	*/
685	int rc = VINF_SUCCESS;
686	int cRequestsCompleted = 0;
687	while (!pCtxInt->fWokenUp)
688	{
689	LNXKAIOIOEVENT aPortEvents[AIO_MAXIMUM_REQUESTS_PER_CONTEXT];
690	int cRequestsToWait = RT_MIN(cReqs, AIO_MAXIMUM_REQUESTS_PER_CONTEXT);
691	ASMAtomicXchgBool(&pCtxInt->fWaiting, true);
692	rc = rtFileAsyncIoLinuxGetEvents(pCtxInt->AioContext, cMinReqs, cRequestsToWait, &aPortEvents[0], pTimeout);
693	ASMAtomicXchgBool(&pCtxInt->fWaiting, false);
694	if (RT_FAILURE(rc))
695	break;
696	uint32_t const cDone = rc;
697	rc = VINF_SUCCESS;
698
699	/*
700	* Process received events / requests.
701	*/
702	for (uint32_t i = 0; i < cDone; i++)
703	{
704	/*
705	* The iocb is the first element in our request structure.
706	* So we can safely cast it directly to the handle (see above)
707	*/
708	PRTFILEAIOREQINTERNAL pReqInt = (PRTFILEAIOREQINTERNAL)aPortEvents[i].pIoCB;
709	AssertPtr(pReqInt);
710	Assert(pReqInt->u32Magic == RTFILEAIOREQ_MAGIC);
711
712	/** @todo aeichner: The rc field contains the result code
713	* like you can find in errno for the normal read/write ops.
714	* But there is a second field called rc2. I don't know the
715	* purpose for it yet.
716	*/
717	if (RT_UNLIKELY(aPortEvents[i].rc < 0))
718	pReqInt->Rc = RTErrConvertFromErrno(aPortEvents[i].rc);
719	else
720	{
721	pReqInt->Rc = VINF_SUCCESS;
722	pReqInt->cbTransfered = aPortEvents[i].rc;
723	}
724
725	/* Mark the request as finished. */
726	RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
727
728	pahReqs[cRequestsCompleted++] = (RTFILEAIOREQ)pReqInt;
729	}
730
731	/*
732	* Done Yet? If not advance and try again.
733	*/
734	if (cDone >= cMinReqs)
735	break;
736	cMinReqs -= cDone;
737	cReqs -= cDone;
738
739	if (cMillisTimeout != RT_INDEFINITE_WAIT)
740	{
741	/* The API doesn't return ETIMEDOUT, so we have to fix that ourselves. */
742	uint64_t NanoTS = RTTimeNanoTS();
743	uint64_t cMilliesElapsed = (NanoTS - StartNanoTS) / 1000000;
744	if (cMilliesElapsed >= cMillisTimeout)
745	{
746	rc = VERR_TIMEOUT;
747	break;
748	}
749
750	/* The syscall supposedly updates it, but we're paranoid. :-) */
751	Timeout.tv_sec = (cMillisTimeout - (unsigned)cMilliesElapsed) / 1000;
752	Timeout.tv_nsec = (cMillisTimeout - (unsigned)cMilliesElapsed) % 1000 * 1000000;
753	}
754	}
755
756	/*
757	* Update the context state and set the return value.
758	*/
759	*pcReqs = cRequestsCompleted;
760	ASMAtomicSubS32(&pCtxInt->cRequests, cRequestsCompleted);
761	Assert(pCtxInt->hThreadWait == RTThreadSelf());
762	ASMAtomicWriteHandle(&pCtxInt->hThreadWait, NIL_RTTHREAD);
763
764	/*
765	* Clear the wakeup flag and set rc.
766	*/
767	if ( pCtxInt->fWokenUp
768	&& RT_SUCCESS(rc))
769	{
770	ASMAtomicXchgBool(&pCtxInt->fWokenUp, false);
771	rc = VERR_INTERRUPTED;
772	}
773
774	return rc;
775	}
776
777
778	RTDECL(int) RTFileAioCtxWakeup(RTFILEAIOCTX hAioCtx)
779	{
780	PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
781	RTFILEAIOCTX_VALID_RETURN(pCtxInt);
782
783	/** @todo r=bird: Define the protocol for how to resume work after calling
784	* this function. */
785
786	bool fWokenUp = ASMAtomicXchgBool(&pCtxInt->fWokenUp, true);
787
788	/*
789	* Read the thread handle before the status flag.
790	* If we read the handle after the flag we might
791	* end up with an invalid handle because the thread
792	* waiting in RTFileAioCtxWakeup() might get scheduled
793	* before we read the flag and returns.
794	* We can ensure that the handle is valid if fWaiting is true
795	* when reading the handle before the status flag.
796	*/
797	RTTHREAD hThread;
798	ASMAtomicReadHandle(&pCtxInt->hThreadWait, &hThread);
799	bool fWaiting = ASMAtomicReadBool(&pCtxInt->fWaiting);
800	if ( !fWokenUp
801	&& fWaiting)
802	{
803	/*
804	* If a thread waits the handle must be valid.
805	* It is possible that the thread returns from
806	* rtFileAsyncIoLinuxGetEvents() before the signal
807	* is send.
808	* This is no problem because we already set fWokenUp
809	* to true which will let the thread return VERR_INTERRUPTED
810	* and the next call to RTFileAioCtxWait() will not
811	* return VERR_INTERRUPTED because signals are not saved
812	* and will simply vanish if the destination thread can't
813	* receive it.
814	*/
815	Assert(hThread != NIL_RTTHREAD);
816	RTThreadPoke(hThread);
817	}
818
819	return VINF_SUCCESS;
820	}
821

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

source: vbox/trunk/src/VBox/Runtime/r3/linux/fileaio-linux.cpp@ 19948

Download in other formats: