VirtualBox

source: vbox/trunk/src/VBox/Runtime/r3/solaris/fileaio-solaris.cpp@ 29004

Last change on this file since 29004 was 28800, checked in by vboxsync, 15 years ago

Automated rebranding to Oracle copyright/license strings via filemuncher
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 17.5 KB
Line 
1/* $Id: fileaio-solaris.cpp 28800 2010-04-27 08:22:32Z vboxsync $ */
2/** @file
3 * IPRT - File async I/O, native implementation for the Solaris host platform.
4 */
5
6/*
7 * Copyright (C) 2006-2010 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* Header Files *
29*******************************************************************************/
30#define LOG_GROUP RTLOGGROUP_FILE
31#include <iprt/asm.h>
32#include <iprt/file.h>
33#include <iprt/mem.h>
34#include <iprt/assert.h>
35#include <iprt/string.h>
36#include <iprt/err.h>
37#include <iprt/log.h>
38#include "internal/fileaio.h"
39
40#include <port.h>
41#include <aio.h>
42#include <errno.h>
43#include <unistd.h>
44
45
46/*******************************************************************************
47* Structures and Typedefs *
48*******************************************************************************/
49/**
50 * Async I/O completion context state.
51 */
52typedef struct RTFILEAIOCTXINTERNAL
53{
54 /** Handle to the port. */
55 int iPort;
56 /** Current number of requests active on this context. */
57 volatile int32_t cRequests;
58 /** Magic value (RTFILEAIOCTX_MAGIC). */
59 uint32_t u32Magic;
60} RTFILEAIOCTXINTERNAL;
61/** Pointer to an internal context structure. */
62typedef RTFILEAIOCTXINTERNAL *PRTFILEAIOCTXINTERNAL;
63
64/**
65 * Async I/O request state.
66 */
67typedef struct RTFILEAIOREQINTERNAL
68{
69 /** The aio control block. Must be the FIRST
70 * element. */
71 struct aiocb AioCB;
72 /** Current state the request is in. */
73 RTFILEAIOREQSTATE enmState;
74 /** Flag whether this is a flush request. */
75 bool fFlush;
76 /** Port notifier object to associate a request to a port. */
77 port_notify_t PortNotifier;
78 /** Opaque user data. */
79 void *pvUser;
80 /** Completion context we are assigned to. */
81 PRTFILEAIOCTXINTERNAL pCtxInt;
82 /** Magic value (RTFILEAIOREQ_MAGIC). */
83 uint32_t u32Magic;
84} RTFILEAIOREQINTERNAL;
85/** Pointer to an internal request structure. */
86typedef RTFILEAIOREQINTERNAL *PRTFILEAIOREQINTERNAL;
87
88
89/*******************************************************************************
90* Defined Constants And Macros *
91*******************************************************************************/
92/** The max number of events to get in one call. */
93#define AIO_MAXIMUM_REQUESTS_PER_CONTEXT 64
94/** Id for the wakeup event. */
95#define AIO_CONTEXT_WAKEUP_EVENT 1
96
97RTR3DECL(int) RTFileAioGetLimits(PRTFILEAIOLIMITS pAioLimits)
98{
99 int rcBSD = 0;
100 AssertPtrReturn(pAioLimits, VERR_INVALID_POINTER);
101
102 /* No limits known. */
103 pAioLimits->cReqsOutstandingMax = RTFILEAIO_UNLIMITED_REQS;
104 pAioLimits->cbBufferAlignment = 0;
105
106 return VINF_SUCCESS;
107}
108
109RTR3DECL(int) RTFileAioReqCreate(PRTFILEAIOREQ phReq)
110{
111 AssertPtrReturn(phReq, VERR_INVALID_POINTER);
112
113 PRTFILEAIOREQINTERNAL pReqInt = (PRTFILEAIOREQINTERNAL)RTMemAllocZ(sizeof(RTFILEAIOREQINTERNAL));
114 if (RT_UNLIKELY(!pReqInt))
115 return VERR_NO_MEMORY;
116
117 /* Ininitialize static parts. */
118 pReqInt->AioCB.aio_sigevent.sigev_notify = SIGEV_PORT;
119 pReqInt->AioCB.aio_sigevent.sigev_value.sival_ptr = &pReqInt->PortNotifier;
120 pReqInt->PortNotifier.portnfy_user = pReqInt;
121 pReqInt->pCtxInt = NULL;
122 pReqInt->u32Magic = RTFILEAIOREQ_MAGIC;
123 RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
124
125 *phReq = (RTFILEAIOREQ)pReqInt;
126
127 return VINF_SUCCESS;
128}
129
130RTDECL(int) RTFileAioReqDestroy(RTFILEAIOREQ hReq)
131{
132 /*
133 * Validate the handle and ignore nil.
134 */
135 if (hReq == NIL_RTFILEAIOREQ)
136 return VINF_SUCCESS;
137 PRTFILEAIOREQINTERNAL pReqInt = hReq;
138 RTFILEAIOREQ_VALID_RETURN(pReqInt);
139 RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS);
140
141 /*
142 * Trash the magic and free it.
143 */
144 ASMAtomicUoWriteU32(&pReqInt->u32Magic, ~RTFILEAIOREQ_MAGIC);
145 RTMemFree(pReqInt);
146 return VINF_SUCCESS;
147}
148
149/**
150 * Worker setting up the request.
151 */
152DECLINLINE(int) rtFileAioReqPrepareTransfer(RTFILEAIOREQ hReq, RTFILE hFile,
153 unsigned uTransferDirection,
154 RTFOFF off, void *pvBuf, size_t cbTransfer,
155 void *pvUser)
156{
157 /*
158 * Validate the input.
159 */
160 PRTFILEAIOREQINTERNAL pReqInt = hReq;
161 RTFILEAIOREQ_VALID_RETURN(pReqInt);
162 RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS);
163 Assert(hFile != NIL_RTFILE);
164 AssertPtr(pvBuf);
165 Assert(off >= 0);
166 Assert(cbTransfer > 0);
167
168 pReqInt->AioCB.aio_lio_opcode = uTransferDirection;
169 pReqInt->AioCB.aio_fildes = (int)hFile;
170 pReqInt->AioCB.aio_offset = off;
171 pReqInt->AioCB.aio_nbytes = cbTransfer;
172 pReqInt->AioCB.aio_buf = pvBuf;
173 pReqInt->fFlush = false;
174 pReqInt->pvUser = pvUser;
175 pReqInt->pCtxInt = NULL;
176 RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
177
178 return VINF_SUCCESS;
179}
180
181RTDECL(int) RTFileAioReqPrepareRead(RTFILEAIOREQ hReq, RTFILE hFile, RTFOFF off,
182 void *pvBuf, size_t cbRead, void *pvUser)
183{
184 return rtFileAioReqPrepareTransfer(hReq, hFile, LIO_READ,
185 off, pvBuf, cbRead, pvUser);
186}
187
188RTDECL(int) RTFileAioReqPrepareWrite(RTFILEAIOREQ hReq, RTFILE hFile, RTFOFF off,
189 void const *pvBuf, size_t cbWrite, void *pvUser)
190{
191 return rtFileAioReqPrepareTransfer(hReq, hFile, LIO_WRITE,
192 off, (void *)pvBuf, cbWrite, pvUser);
193}
194
195RTDECL(int) RTFileAioReqPrepareFlush(RTFILEAIOREQ hReq, RTFILE hFile, void *pvUser)
196{
197 PRTFILEAIOREQINTERNAL pReqInt = (PRTFILEAIOREQINTERNAL)hReq;
198
199 RTFILEAIOREQ_VALID_RETURN(pReqInt);
200 RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS);
201 Assert(hFile != NIL_RTFILE);
202
203 pReqInt->fFlush = true;
204 pReqInt->AioCB.aio_fildes = (int)hFile;
205 pReqInt->pvUser = pvUser;
206 RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
207
208 return VINF_SUCCESS;
209}
210
211RTDECL(void *) RTFileAioReqGetUser(RTFILEAIOREQ hReq)
212{
213 PRTFILEAIOREQINTERNAL pReqInt = hReq;
214 RTFILEAIOREQ_VALID_RETURN_RC(pReqInt, NULL);
215
216 return pReqInt->pvUser;
217}
218
219RTDECL(int) RTFileAioReqCancel(RTFILEAIOREQ hReq)
220{
221 PRTFILEAIOREQINTERNAL pReqInt = hReq;
222 RTFILEAIOREQ_VALID_RETURN(pReqInt);
223 RTFILEAIOREQ_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_NOT_SUBMITTED);
224
225 int rcSolaris = aio_cancel(pReqInt->AioCB.aio_fildes, &pReqInt->AioCB);
226
227 if (rcSolaris == AIO_CANCELED)
228 {
229 /*
230 * Decrement request count because the request will never arrive at the
231 * completion port.
232 */
233 AssertMsg(VALID_PTR(pReqInt->pCtxInt),
234 ("Invalid state. Request was canceled but wasn't submitted\n"));
235
236 ASMAtomicDecS32(&pReqInt->pCtxInt->cRequests);
237 RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
238 return VINF_SUCCESS;
239 }
240 else if (rcSolaris == AIO_ALLDONE)
241 return VERR_FILE_AIO_COMPLETED;
242 else if (rcSolaris == AIO_NOTCANCELED)
243 return VERR_FILE_AIO_IN_PROGRESS;
244 else
245 return RTErrConvertFromErrno(errno);
246}
247
248RTDECL(int) RTFileAioReqGetRC(RTFILEAIOREQ hReq, size_t *pcbTransfered)
249{
250 PRTFILEAIOREQINTERNAL pReqInt = hReq;
251 RTFILEAIOREQ_VALID_RETURN(pReqInt);
252 RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, SUBMITTED, VERR_FILE_AIO_IN_PROGRESS);
253 RTFILEAIOREQ_NOT_STATE_RETURN_RC(pReqInt, PREPARED, VERR_FILE_AIO_NOT_SUBMITTED);
254 AssertPtrNull(pcbTransfered);
255
256 int rcSol = aio_error(&pReqInt->AioCB);
257 Assert(rcSol != EINPROGRESS); /* Handled by our own state handling. */
258
259 if (rcSol == 0)
260 {
261 if (pcbTransfered)
262 *pcbTransfered = aio_return(&pReqInt->AioCB);
263 return VINF_SUCCESS;
264 }
265
266 /* An error occurred. */
267 return RTErrConvertFromErrno(rcSol);
268}
269
270RTDECL(int) RTFileAioCtxCreate(PRTFILEAIOCTX phAioCtx, uint32_t cAioReqsMax)
271{
272 int rc = VINF_SUCCESS;
273 PRTFILEAIOCTXINTERNAL pCtxInt;
274 AssertPtrReturn(phAioCtx, VERR_INVALID_POINTER);
275
276 pCtxInt = (PRTFILEAIOCTXINTERNAL)RTMemAllocZ(sizeof(RTFILEAIOCTXINTERNAL));
277 if (RT_UNLIKELY(!pCtxInt))
278 return VERR_NO_MEMORY;
279
280 /* Init the event handle. */
281 pCtxInt->iPort = port_create();
282 if (RT_LIKELY(pCtxInt->iPort > 0))
283 {
284 pCtxInt->u32Magic = RTFILEAIOCTX_MAGIC;
285 *phAioCtx = (RTFILEAIOCTX)pCtxInt;
286 }
287 else
288 {
289 RTMemFree(pCtxInt);
290 rc = RTErrConvertFromErrno(errno);
291 }
292
293 return rc;
294}
295
296RTDECL(int) RTFileAioCtxDestroy(RTFILEAIOCTX hAioCtx)
297{
298 /* Validate the handle and ignore nil. */
299 if (hAioCtx == NIL_RTFILEAIOCTX)
300 return VINF_SUCCESS;
301 PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
302 RTFILEAIOCTX_VALID_RETURN(pCtxInt);
303
304 /* Cannot destroy a busy context. */
305 if (RT_UNLIKELY(pCtxInt->cRequests))
306 return VERR_FILE_AIO_BUSY;
307
308 close(pCtxInt->iPort);
309 ASMAtomicUoWriteU32(&pCtxInt->u32Magic, RTFILEAIOCTX_MAGIC_DEAD);
310 RTMemFree(pCtxInt);
311
312 return VINF_SUCCESS;
313}
314
315RTDECL(uint32_t) RTFileAioCtxGetMaxReqCount(RTFILEAIOCTX hAioCtx)
316{
317 return RTFILEAIO_UNLIMITED_REQS;
318}
319
320RTDECL(int) RTFileAioCtxAssociateWithFile(RTFILEAIOCTX hAioCtx, RTFILE hFile)
321{
322 return VINF_SUCCESS;
323}
324
325RTDECL(int) RTFileAioCtxSubmit(RTFILEAIOCTX hAioCtx, PRTFILEAIOREQ pahReqs, size_t cReqs)
326{
327 /*
328 * Parameter validation.
329 */
330 int rc = VINF_SUCCESS;
331 PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
332 RTFILEAIOCTX_VALID_RETURN(pCtxInt);
333 AssertReturn(cReqs > 0, VERR_INVALID_PARAMETER);
334 AssertPtrReturn(pahReqs, VERR_INVALID_POINTER);
335 size_t i = cReqs;
336
337 do
338 {
339 int rcSol = 0;
340 size_t cReqsSubmit = 0;
341 PRTFILEAIOREQINTERNAL pReqInt;
342
343 while(i-- > 0)
344 {
345 pReqInt = pahReqs[i];
346 if (RTFILEAIOREQ_IS_NOT_VALID(pReqInt))
347 {
348 /* Undo everything and stop submitting. */
349 for (size_t iUndo = 0; iUndo < i; iUndo++)
350 {
351 pReqInt = pahReqs[iUndo];
352 RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
353 pReqInt->pCtxInt = NULL;
354 }
355 rc = VERR_INVALID_HANDLE;
356 break;
357 }
358
359 pReqInt->PortNotifier.portnfy_port = pCtxInt->iPort;
360 pReqInt->pCtxInt = pCtxInt;
361 RTFILEAIOREQ_SET_STATE(pReqInt, SUBMITTED);
362
363 if (pReqInt->fFlush)
364 break;
365
366 cReqsSubmit++;
367 }
368
369 if (cReqsSubmit)
370 {
371 rcSol = lio_listio(LIO_NOWAIT, (struct aiocb **)pahReqs, cReqsSubmit, NULL);
372 if (RT_UNLIKELY(rcSol < 0))
373 {
374 if (rcSol == EAGAIN)
375 rc = VERR_FILE_AIO_INSUFFICIENT_RESSOURCES;
376 else
377 rc = RTErrConvertFromErrno(errno);
378
379 /* Check which requests got actually submitted and which not. */
380 for (i = 0; i < cReqs; i++)
381 {
382 pReqInt = pahReqs[i];
383 rcSol = aio_error(&pReqInt->AioCB);
384 if (rcSol == EINVAL)
385 {
386 /* Was not submitted. */
387 RTFILEAIOREQ_SET_STATE(pReqInt, PREPARED);
388 pReqInt->pCtxInt = NULL;
389 }
390 else if (rcSol != EINPROGRESS)
391 {
392 /* The request encountered an error. */
393 RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
394 }
395 }
396 break;
397 }
398
399 ASMAtomicAddS32(&pCtxInt->cRequests, cReqsSubmit);
400 cReqs -= cReqsSubmit;
401 pahReqs += cReqsSubmit;
402 }
403
404 if (cReqs)
405 {
406 pReqInt = pahReqs[0];
407 RTFILEAIOREQ_VALID_RETURN(pReqInt);
408
409 /*
410 * If there are still requests left we have a flush request.
411 * lio_listio does not work with this requests so
412 * we have to use aio_fsync directly.
413 */
414 rcSol = aio_fsync(O_SYNC, &pReqInt->AioCB);
415 if (RT_UNLIKELY(rcSol < 0))
416 {
417 RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
418 rc = RTErrConvertFromErrno(errno);
419 break;
420 }
421
422 ASMAtomicIncS32(&pCtxInt->cRequests);
423 cReqs--;
424 pahReqs++;
425 }
426 } while (cReqs);
427
428 return rc;
429}
430
431RTDECL(int) RTFileAioCtxWait(RTFILEAIOCTX hAioCtx, size_t cMinReqs, RTMSINTERVAL cMillies,
432 PRTFILEAIOREQ pahReqs, size_t cReqs, uint32_t *pcReqs)
433{
434 int rc = VINF_SUCCESS;
435 int cRequestsCompleted = 0;
436
437 /*
438 * Validate the parameters, making sure to always set pcReqs.
439 */
440 AssertPtrReturn(pcReqs, VERR_INVALID_POINTER);
441 *pcReqs = 0; /* always set */
442 PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
443 RTFILEAIOCTX_VALID_RETURN(pCtxInt);
444 AssertPtrReturn(pahReqs, VERR_INVALID_POINTER);
445 AssertReturn(cReqs != 0, VERR_INVALID_PARAMETER);
446 AssertReturn(cReqs >= cMinReqs, VERR_OUT_OF_RANGE);
447
448 if (RT_UNLIKELY(ASMAtomicReadS32(&pCtxInt->cRequests) == 0))
449 return VERR_FILE_AIO_NO_REQUEST;
450
451 /*
452 * Convert the timeout if specified.
453 */
454 struct timespec *pTimeout = NULL;
455 struct timespec Timeout = {0,0};
456 uint64_t StartNanoTS = 0;
457 if (cMillies != RT_INDEFINITE_WAIT)
458 {
459 Timeout.tv_sec = cMillies / 1000;
460 Timeout.tv_nsec = cMillies % 1000 * 1000000;
461 pTimeout = &Timeout;
462 StartNanoTS = RTTimeNanoTS();
463 }
464
465 /* Wait for at least one. */
466 if (!cMinReqs)
467 cMinReqs = 1;
468
469 while ( cMinReqs
470 && RT_SUCCESS_NP(rc))
471 {
472 port_event_t aPortEvents[AIO_MAXIMUM_REQUESTS_PER_CONTEXT];
473 uint_t cRequests = cMinReqs;
474 int cRequestsToWait = cMinReqs < AIO_MAXIMUM_REQUESTS_PER_CONTEXT ? cReqs : AIO_MAXIMUM_REQUESTS_PER_CONTEXT;
475 int rcSol;
476 uint64_t StartTime;
477
478 rcSol = port_getn(pCtxInt->iPort, &aPortEvents[0], cRequestsToWait, &cRequests, pTimeout);
479
480 if (RT_UNLIKELY(rcSol < 0))
481 rc = RTErrConvertFromErrno(errno);
482
483 /* Process received events. */
484 for (uint_t i = 0; i < cRequests; i++)
485 {
486 if (aPortEvents[i].portev_source == PORT_SOURCE_ALERT)
487 {
488 Assert(aPortEvents[i].portev_events == AIO_CONTEXT_WAKEUP_EVENT);
489 rc = VERR_INTERRUPTED; /* We've got interrupted. */
490 /* Reset the port. */
491 port_alert(pCtxInt->iPort, PORT_ALERT_SET, 0, NULL);
492 }
493 else
494 {
495 PRTFILEAIOREQINTERNAL pReqInt = (PRTFILEAIOREQINTERNAL)aPortEvents[i].portev_user;
496 AssertPtr(pReqInt);
497 Assert(pReqInt->u32Magic == RTFILEAIOREQ_MAGIC);
498
499 /* A request has finished. */
500 pahReqs[cRequestsCompleted++] = pReqInt;
501
502 /* Mark the request as finished. */
503 RTFILEAIOREQ_SET_STATE(pReqInt, COMPLETED);
504 }
505 }
506
507 /*
508 * Done Yet? If not advance and try again.
509 */
510 if (cRequests >= cMinReqs)
511 break;
512 cMinReqs -= cRequests;
513 cReqs -= cRequests;
514
515 if (cMillies != RT_INDEFINITE_WAIT)
516 {
517 uint64_t NanoTS = RTTimeNanoTS();
518 uint64_t cMilliesElapsed = (NanoTS - StartNanoTS) / 1000000;
519
520 /* The syscall supposedly updates it, but we're paranoid. :-) */
521 if (cMilliesElapsed < cMillies)
522 {
523 Timeout.tv_sec = (cMillies - (RTMSINTERVAL)cMilliesElapsed) / 1000;
524 Timeout.tv_nsec = (cMillies - (RTMSINTERVAL)cMilliesElapsed) % 1000 * 1000000;
525 }
526 else
527 {
528 Timeout.tv_sec = 0;
529 Timeout.tv_nsec = 0;
530 }
531 }
532 }
533
534 /*
535 * Update the context state and set the return value.
536 */
537 *pcReqs = cRequestsCompleted;
538 ASMAtomicSubS32(&pCtxInt->cRequests, cRequestsCompleted);
539
540 return rc;
541}
542
543RTDECL(int) RTFileAioCtxWakeup(RTFILEAIOCTX hAioCtx)
544{
545 int rc = VINF_SUCCESS;
546 PRTFILEAIOCTXINTERNAL pCtxInt = hAioCtx;
547 RTFILEAIOCTX_VALID_RETURN(pCtxInt);
548
549 rc = port_alert(pCtxInt->iPort, PORT_ALERT_UPDATE, AIO_CONTEXT_WAKEUP_EVENT, NULL);
550 if (RT_UNLIKELY((rc < 0) && (errno != EBUSY)))
551 return RTErrConvertFromErrno(errno);
552
553 return VINF_SUCCESS;
554}
555
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette