?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / lib / libc / port / aio / posix_aio.c
blobf1f23ffa62847304e8ce80400140579f82a59341
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * posix_aio.c implements the POSIX async. I/O functions.
29 *
30 * aio_read
31 * aio_write
32 * aio_error
33 * aio_return
34 * aio_suspend
35 * lio_listio
36 * aio_fsync
37 * aio_cancel
38 */
39
40 #include "lint.h"
41 #include "thr_uberdata.h"
42 #include "asyncio.h"
43 #include <atomic.h>
44 #include <sys/file.h>
45 #include <sys/port.h>
46
47 extern int __fdsync(int, int);
48
49 cond_t _aio_waitn_cv = DEFAULTCV; /* wait for end of aio_waitn */
50
51 static int _aio_check_timeout(const timespec_t *, timespec_t *, int *);
52
53 /* defines for timedwait in __aio_waitn() and __aio_suspend() */
54 #define AIO_TIMEOUT_INDEF -1
55 #define AIO_TIMEOUT_POLL 0
56 #define AIO_TIMEOUT_WAIT 1
57 #define AIO_TIMEOUT_UNDEF 2
58
59 /*
60 * List I/O stuff
61 */
62 static void _lio_list_decr(aio_lio_t *);
63 static long aio_list_max = 0;
64
65 int
66 aio_read(aiocb_t *aiocbp)
67 {
68 if (aiocbp == NULL || aiocbp->aio_reqprio != 0) {
69 errno = EINVAL;
70 return (-1);
71 }
72 if (_aio_hash_find(&aiocbp->aio_resultp) != NULL) {
73 errno = EBUSY;
74 return (-1);
75 }
76 if (_aio_sigev_thread(aiocbp) != 0)
77 return (-1);
78 aiocbp->aio_lio_opcode = LIO_READ;
79 return (_aio_rw(aiocbp, NULL, &__nextworker_rw, AIOAREAD,
80 (AIO_KAIO | AIO_NO_DUPS)));
81 }
82
83 int
84 aio_write(aiocb_t *aiocbp)
85 {
86 if (aiocbp == NULL || aiocbp->aio_reqprio != 0) {
87 errno = EINVAL;
88 return (-1);
89 }
90 if (_aio_hash_find(&aiocbp->aio_resultp) != NULL) {
91 errno = EBUSY;
92 return (-1);
93 }
94 if (_aio_sigev_thread(aiocbp) != 0)
95 return (-1);
96 aiocbp->aio_lio_opcode = LIO_WRITE;
97 return (_aio_rw(aiocbp, NULL, &__nextworker_rw, AIOAWRITE,
98 (AIO_KAIO | AIO_NO_DUPS)));
99 }
100
101 /*
102 * __lio_listio() cancellation handler.
103 */
104 /* ARGSUSED */
105 static void
106 _lio_listio_cleanup(aio_lio_t *head)
107 {
108 int freeit = 0;
109
110 ASSERT(MUTEX_HELD(&head->lio_mutex));
111 if (head->lio_refcnt == 0) {
112 ASSERT(head->lio_nent == 0);
113 freeit = 1;
114 }
115 head->lio_waiting = 0;
116 sig_mutex_unlock(&head->lio_mutex);
117 if (freeit)
118 _aio_lio_free(head);
119 }
120
121 int
122 lio_listio(int mode, aiocb_t *_RESTRICT_KYWD const *_RESTRICT_KYWD list,
123 int nent, struct sigevent *_RESTRICT_KYWD sigevp)
124 {
125 int aio_ufs = 0;
126 int oerrno = 0;
127 aio_lio_t *head = NULL;
128 aiocb_t *aiocbp;
129 int state = 0;
130 int EIOflg = 0;
131 int rw;
132 int do_kaio = 0;
133 int error;
134 int i;
135
136 if (!_kaio_ok)
137 _kaio_init();
138
139 if (aio_list_max == 0)
140 aio_list_max = sysconf(_SC_AIO_LISTIO_MAX);
141
142 if (nent <= 0 || nent > aio_list_max) {
143 errno = EINVAL;
144 return (-1);
145 }
146
147 switch (mode) {
148 case LIO_WAIT:
149 state = NOCHECK;
150 break;
151 case LIO_NOWAIT:
152 state = CHECK;
153 break;
154 default:
155 errno = EINVAL;
156 return (-1);
157 }
158
159 for (i = 0; i < nent; i++) {
160 if ((aiocbp = list[i]) == NULL)
161 continue;
162 if (_aio_hash_find(&aiocbp->aio_resultp) != NULL) {
163 errno = EBUSY;
164 return (-1);
165 }
166 if (_aio_sigev_thread(aiocbp) != 0)
167 return (-1);
168 if (aiocbp->aio_lio_opcode == LIO_NOP)
169 aiocbp->aio_state = NOCHECK;
170 else {
171 aiocbp->aio_state = state;
172 if (KAIO_SUPPORTED(aiocbp->aio_fildes))
173 do_kaio++;
174 else
175 aiocbp->aio_resultp.aio_errno = ENOTSUP;
176 }
177 }
178 if (_aio_sigev_thread_init(sigevp) != 0)
179 return (-1);
180
181 if (do_kaio) {
182 error = (int)_kaio(AIOLIO, mode, list, nent, sigevp);
183 if (error == 0)
184 return (0);
185 oerrno = errno;
186 } else {
187 oerrno = errno = ENOTSUP;
188 error = -1;
189 }
190
191 if (error == -1 && errno == ENOTSUP) {
192 error = errno = 0;
193 /*
194 * If LIO_WAIT, or notification required, allocate a list head.
195 */
196 if (mode == LIO_WAIT ||
197 (sigevp != NULL &&
198 (sigevp->sigev_notify == SIGEV_SIGNAL ||
199 sigevp->sigev_notify == SIGEV_THREAD ||
200 sigevp->sigev_notify == SIGEV_PORT)))
201 head = _aio_lio_alloc();
202 if (head) {
203 sig_mutex_lock(&head->lio_mutex);
204 head->lio_mode = mode;
205 head->lio_largefile = 0;
206 if (mode == LIO_NOWAIT && sigevp != NULL) {
207 if (sigevp->sigev_notify == SIGEV_THREAD) {
208 head->lio_port = sigevp->sigev_signo;
209 head->lio_event = AIOLIO;
210 head->lio_sigevent = sigevp;
211 head->lio_sigval.sival_ptr =
212 sigevp->sigev_value.sival_ptr;
213 } else if (sigevp->sigev_notify == SIGEV_PORT) {
214 port_notify_t *pn =
215 sigevp->sigev_value.sival_ptr;
216 head->lio_port = pn->portnfy_port;
217 head->lio_event = AIOLIO;
218 head->lio_sigevent = sigevp;
219 head->lio_sigval.sival_ptr =
220 pn->portnfy_user;
221 } else { /* SIGEV_SIGNAL */
222 head->lio_signo = sigevp->sigev_signo;
223 head->lio_sigval.sival_ptr =
224 sigevp->sigev_value.sival_ptr;
225 }
226 }
227 head->lio_nent = head->lio_refcnt = nent;
228 sig_mutex_unlock(&head->lio_mutex);
229 }
230 /*
231 * find UFS requests, errno == ENOTSUP/EBADFD,
232 */
233 for (i = 0; i < nent; i++) {
234 if ((aiocbp = list[i]) == NULL ||
235 aiocbp->aio_lio_opcode == LIO_NOP ||
236 (aiocbp->aio_resultp.aio_errno != ENOTSUP &&
237 aiocbp->aio_resultp.aio_errno != EBADFD)) {
238 if (head)
239 _lio_list_decr(head);
240 continue;
241 }
242 if (aiocbp->aio_resultp.aio_errno == EBADFD)
243 SET_KAIO_NOT_SUPPORTED(aiocbp->aio_fildes);
244 if (aiocbp->aio_reqprio != 0) {
245 aiocbp->aio_resultp.aio_errno = EINVAL;
246 aiocbp->aio_resultp.aio_return = -1;
247 EIOflg = 1;
248 if (head)
249 _lio_list_decr(head);
250 continue;
251 }
252 /*
253 * submit an AIO request with flags AIO_NO_KAIO
254 * to avoid the kaio() syscall in _aio_rw()
255 */
256 switch (aiocbp->aio_lio_opcode) {
257 case LIO_READ:
258 rw = AIOAREAD;
259 break;
260 case LIO_WRITE:
261 rw = AIOAWRITE;
262 break;
263 }
264 error = _aio_rw(aiocbp, head, &__nextworker_rw, rw,
265 (AIO_NO_KAIO | AIO_NO_DUPS));
266 if (error == 0)
267 aio_ufs++;
268 else {
269 if (head)
270 _lio_list_decr(head);
271 aiocbp->aio_resultp.aio_errno = error;
272 EIOflg = 1;
273 }
274 }
275 }
276 if (EIOflg) {
277 errno = EIO;
278 return (-1);
279 }
280 if (mode == LIO_WAIT && oerrno == ENOTSUP) {
281 /*
282 * call kaio(AIOLIOWAIT) to get all outstanding
283 * kernel AIO requests
284 */
285 if ((nent - aio_ufs) > 0)
286 (void) _kaio(AIOLIOWAIT, mode, list, nent, sigevp);
287 if (head != NULL && head->lio_nent > 0) {
288 sig_mutex_lock(&head->lio_mutex);
289 while (head->lio_refcnt > 0) {
290 int err;
291 head->lio_waiting = 1;
292 pthread_cleanup_push(_lio_listio_cleanup, head);
293 err = sig_cond_wait(&head->lio_cond_cv,
294 &head->lio_mutex);
295 pthread_cleanup_pop(0);
296 head->lio_waiting = 0;
297 if (err && head->lio_nent > 0) {
298 sig_mutex_unlock(&head->lio_mutex);
299 errno = err;
300 return (-1);
301 }
302 }
303 sig_mutex_unlock(&head->lio_mutex);
304 ASSERT(head->lio_nent == 0 && head->lio_refcnt == 0);
305 _aio_lio_free(head);
306 for (i = 0; i < nent; i++) {
307 if ((aiocbp = list[i]) != NULL &&
308 aiocbp->aio_resultp.aio_errno) {
309 errno = EIO;
310 return (-1);
311 }
312 }
313 }
314 return (0);
315 }
316 return (error);
317 }
318
319 static void
320 _lio_list_decr(aio_lio_t *head)
321 {
322 sig_mutex_lock(&head->lio_mutex);
323 head->lio_nent--;
324 head->lio_refcnt--;
325 sig_mutex_unlock(&head->lio_mutex);
326 }
327
328 /*
329 * __aio_suspend() cancellation handler.
330 */
331 /* ARGSUSED */
332 static void
333 _aio_suspend_cleanup(int *counter)
334 {
335 ASSERT(MUTEX_HELD(&__aio_mutex));
336 (*counter)--; /* _aio_kernel_suspend or _aio_suscv_cnt */
337 sig_mutex_unlock(&__aio_mutex);
338 }
339
340 static int
341 __aio_suspend(void **list, int nent, const timespec_t *timo, int largefile)
342 {
343 int cv_err; /* error code from cond_xxx() */
344 int kerr; /* error code from _kaio(AIOSUSPEND) */
345 int i;
346 timespec_t twait; /* copy of timo for internal calculations */
347 timespec_t *wait = NULL;
348 int timedwait;
349 int req_outstanding;
350 aiocb_t **listp;
351 aiocb_t *aiocbp;
352 #if !defined(_LP64)
353 aiocb64_t **listp64;
354 aiocb64_t *aiocbp64;
355 #endif
356 hrtime_t hrtstart;
357 hrtime_t hrtend;
358 hrtime_t hrtres;
359
360 #if defined(_LP64)
361 if (largefile)
362 aio_panic("__aio_suspend: largefile set when _LP64 defined");
363 #endif
364
365 if (nent <= 0) {
366 errno = EINVAL;
367 return (-1);
368 }
369
370 if (timo) {
371 if (timo->tv_sec < 0 || timo->tv_nsec < 0 ||
372 timo->tv_nsec >= NANOSEC) {
373 errno = EINVAL;
374 return (-1);
375 }
376 /* Initialize start time if time monitoring desired */
377 if (timo->tv_sec > 0 || timo->tv_nsec > 0) {
378 timedwait = AIO_TIMEOUT_WAIT;
379 hrtstart = gethrtime();
380 } else {
381 /* content of timeout = 0 : polling */
382 timedwait = AIO_TIMEOUT_POLL;
383 }
384 } else {
385 /* timeout pointer = NULL : wait indefinitely */
386 timedwait = AIO_TIMEOUT_INDEF;
387 }
388
389 #if !defined(_LP64)
390 if (largefile) {
391 listp64 = (aiocb64_t **)list;
392 for (i = 0; i < nent; i++) {
393 if ((aiocbp64 = listp64[i]) != NULL &&
394 aiocbp64->aio_state == CHECK)
395 aiocbp64->aio_state = CHECKED;
396 }
397 } else
398 #endif /* !_LP64 */
399 {
400 listp = (aiocb_t **)list;
401 for (i = 0; i < nent; i++) {
402 if ((aiocbp = listp[i]) != NULL &&
403 aiocbp->aio_state == CHECK)
404 aiocbp->aio_state = CHECKED;
405 }
406 }
407
408 sig_mutex_lock(&__aio_mutex);
409
410 /*
411 * The next "if -case" is required to accelerate the
412 * access to completed RAW-IO requests.
413 */
414 if ((_aio_doneq_cnt + _aio_outstand_cnt) == 0) {
415 /* Only kernel requests pending */
416
417 /*
418 * _aio_kernel_suspend is used to detect completed non RAW-IO
419 * requests.
420 * As long as this thread resides in the kernel (_kaio) further
421 * asynchronous non RAW-IO requests could be submitted.
422 */
423 _aio_kernel_suspend++;
424
425 /*
426 * Always do the kaio() call without using the KAIO_SUPPORTED()
427 * checks because it is not mandatory to have a valid fd
428 * set in the list entries, only the resultp must be set.
429 *
430 * _kaio(AIOSUSPEND ...) return values :
431 * 0: everythink ok, completed request found
432 * -1: error
433 * 1: no error : _aiodone awaked the _kaio(AIOSUSPEND,,)
434 * system call using _kaio(AIONOTIFY). It means, that some
435 * non RAW-IOs completed inbetween.
436 */
437
438 pthread_cleanup_push(_aio_suspend_cleanup,
439 &_aio_kernel_suspend);
440 pthread_cleanup_push(sig_mutex_lock, &__aio_mutex);
441 sig_mutex_unlock(&__aio_mutex);
442 _cancel_prologue();
443 kerr = (int)_kaio(largefile? AIOSUSPEND64 : AIOSUSPEND,
444 list, nent, timo, -1);
445 _cancel_epilogue();
446 pthread_cleanup_pop(1); /* sig_mutex_lock(&__aio_mutex) */
447 pthread_cleanup_pop(0);
448
449 _aio_kernel_suspend--;
450
451 if (!kerr) {
452 sig_mutex_unlock(&__aio_mutex);
453 return (0);
454 }
455 } else {
456 kerr = 1; /* simulation: _kaio detected AIONOTIFY */
457 }
458
459 /*
460 * Return kernel error code if no other IOs are outstanding.
461 */
462 req_outstanding = _aio_doneq_cnt + _aio_outstand_cnt;
463
464 sig_mutex_unlock(&__aio_mutex);
465
466 if (req_outstanding == 0) {
467 /* no IOs outstanding in the thread pool */
468 if (kerr == 1)
469 /* return "no IOs completed" */
470 errno = EAGAIN;
471 return (-1);
472 }
473
474 /*
475 * IOs using the thread pool are outstanding.
476 */
477 if (timedwait == AIO_TIMEOUT_WAIT) {
478 /* time monitoring */
479 hrtend = hrtstart + (hrtime_t)timo->tv_sec * (hrtime_t)NANOSEC +
480 (hrtime_t)timo->tv_nsec;
481 hrtres = hrtend - gethrtime();
482 if (hrtres <= 0)
483 hrtres = 1;
484 twait.tv_sec = hrtres / (hrtime_t)NANOSEC;
485 twait.tv_nsec = hrtres % (hrtime_t)NANOSEC;
486 wait = &twait;
487 } else if (timedwait == AIO_TIMEOUT_POLL) {
488 twait = *timo; /* content of timo = 0 : polling */
489 wait = &twait;
490 }
491
492 for (;;) {
493 int error;
494 int inprogress;
495
496 /* first scan file system requests */
497 inprogress = 0;
498 for (i = 0; i < nent; i++) {
499 #if !defined(_LP64)
500 if (largefile) {
501 if ((aiocbp64 = listp64[i]) == NULL)
502 continue;
503 error = aiocbp64->aio_resultp.aio_errno;
504 } else
505 #endif
506 {
507 if ((aiocbp = listp[i]) == NULL)
508 continue;
509 error = aiocbp->aio_resultp.aio_errno;
510 }
511 if (error == EINPROGRESS)
512 inprogress = 1;
513 else if (error != ECANCELED) {
514 errno = 0;
515 return (0);
516 }
517 }
518
519 sig_mutex_lock(&__aio_mutex);
520
521 /*
522 * If there aren't outstanding I/Os in the thread pool then
523 * we have to return here, provided that all kernel RAW-IOs
524 * also completed.
525 * If the kernel was notified to return, then we have to check
526 * possible pending RAW-IOs.
527 */
528 if (_aio_outstand_cnt == 0 && inprogress == 0 && kerr != 1) {
529 sig_mutex_unlock(&__aio_mutex);
530 errno = EAGAIN;
531 break;
532 }
533
534 /*
535 * There are outstanding IOs in the thread pool or the kernel
536 * was notified to return.
537 * Check pending RAW-IOs first.
538 */
539 if (kerr == 1) {
540 /*
541 * _aiodone just notified the kernel about
542 * completed non RAW-IOs (AIONOTIFY was detected).
543 */
544 if (timedwait == AIO_TIMEOUT_WAIT) {
545 /* Update remaining timeout for the kernel */
546 hrtres = hrtend - gethrtime();
547 if (hrtres <= 0) {
548 /* timer expired */
549 sig_mutex_unlock(&__aio_mutex);
550 errno = EAGAIN;
551 break;
552 }
553 wait->tv_sec = hrtres / (hrtime_t)NANOSEC;
554 wait->tv_nsec = hrtres % (hrtime_t)NANOSEC;
555 }
556 _aio_kernel_suspend++;
557
558 pthread_cleanup_push(_aio_suspend_cleanup,
559 &_aio_kernel_suspend);
560 pthread_cleanup_push(sig_mutex_lock, &__aio_mutex);
561 sig_mutex_unlock(&__aio_mutex);
562 _cancel_prologue();
563 kerr = (int)_kaio(largefile? AIOSUSPEND64 : AIOSUSPEND,
564 list, nent, wait, -1);
565 _cancel_epilogue();
566 pthread_cleanup_pop(1);
567 pthread_cleanup_pop(0);
568
569 _aio_kernel_suspend--;
570
571 if (!kerr) {
572 sig_mutex_unlock(&__aio_mutex);
573 return (0);
574 }
575 }
576
577 if (timedwait == AIO_TIMEOUT_POLL) {
578 sig_mutex_unlock(&__aio_mutex);
579 errno = EAGAIN;
580 break;
581 }
582
583 if (timedwait == AIO_TIMEOUT_WAIT) {
584 /* Update remaining timeout */
585 hrtres = hrtend - gethrtime();
586 if (hrtres <= 0) {
587 /* timer expired */
588 sig_mutex_unlock(&__aio_mutex);
589 errno = EAGAIN;
590 break;
591 }
592 wait->tv_sec = hrtres / (hrtime_t)NANOSEC;
593 wait->tv_nsec = hrtres % (hrtime_t)NANOSEC;
594 }
595
596 if (_aio_outstand_cnt == 0) {
597 sig_mutex_unlock(&__aio_mutex);
598 continue;
599 }
600
601 _aio_suscv_cnt++; /* ID for _aiodone (wake up) */
602
603 pthread_cleanup_push(_aio_suspend_cleanup, &_aio_suscv_cnt);
604 if (timedwait == AIO_TIMEOUT_WAIT) {
605 cv_err = sig_cond_reltimedwait(&_aio_iowait_cv,
606 &__aio_mutex, wait);
607 if (cv_err == ETIME)
608 cv_err = EAGAIN;
609 } else {
610 /* wait indefinitely */
611 cv_err = sig_cond_wait(&_aio_iowait_cv, &__aio_mutex);
612 }
613 /* this decrements _aio_suscv_cnt and drops __aio_mutex */
614 pthread_cleanup_pop(1);
615
616 if (cv_err) {
617 errno = cv_err;
618 break;
619 }
620 }
621 return (-1);
622 }
623
624 int
625 aio_suspend(const aiocb_t * const list[], int nent,
626 const timespec_t *timeout)
627 {
628 return (__aio_suspend((void **)list, nent, timeout, 0));
629 }
630
631 int
632 aio_error(const aiocb_t *aiocbp)
633 {
634 const aio_result_t *resultp = &aiocbp->aio_resultp;
635 aio_req_t *reqp;
636 int error;
637
638 if ((error = resultp->aio_errno) == EINPROGRESS) {
639 if (aiocbp->aio_state == CHECK) {
640 /*
641 * Always do the kaio() call without using the
642 * KAIO_SUPPORTED() checks because it is not
643 * mandatory to have a valid fd set in the
644 * aiocb, only the resultp must be set.
645 */
646 if ((int)_kaio(AIOERROR, aiocbp) == EINVAL) {
647 errno = EINVAL;
648 return (-1);
649 }
650 error = resultp->aio_errno;
651 } else if (aiocbp->aio_state == CHECKED) {
652 ((aiocb_t *)aiocbp)->aio_state = CHECK;
653 }
654 } else if (aiocbp->aio_state == USERAIO) {
655 sig_mutex_lock(&__aio_mutex);
656 if ((reqp = _aio_hash_del((aio_result_t *)resultp)) == NULL) {
657 sig_mutex_unlock(&__aio_mutex);
658 ((aiocb_t *)aiocbp)->aio_state = CHECKED;
659 } else {
660 ((aiocb_t *)aiocbp)->aio_state = NOCHECK;
661 ASSERT(reqp->req_head == NULL);
662 (void) _aio_req_remove(reqp);
663 sig_mutex_unlock(&__aio_mutex);
664 _aio_req_free(reqp);
665 }
666 }
667 return (error);
668 }
669
670 ssize_t
671 aio_return(aiocb_t *aiocbp)
672 {
673 aio_result_t *resultp = &aiocbp->aio_resultp;
674 aio_req_t *reqp;
675 int error;
676 ssize_t retval;
677
678 /*
679 * The _aiodone() function stores resultp->aio_return before
680 * storing resultp->aio_errno (with an membar_producer() in
681 * between). We use membar_consumer() below to ensure proper
682 * memory ordering between _aiodone() and ourself.
683 */
684 error = resultp->aio_errno;
685 membar_consumer();
686 retval = resultp->aio_return;
687
688 /*
689 * we use this condition to indicate either that
690 * aio_return() has been called before or should
691 * not have been called yet.
692 */
693 if ((retval == -1 && error == EINVAL) || error == EINPROGRESS) {
694 errno = error;
695 return (-1);
696 }
697
698 /*
699 * Before we return, mark the result as being returned so that later
700 * calls to aio_return() will return the fact that the result has
701 * already been returned.
702 */
703 sig_mutex_lock(&__aio_mutex);
704 /* retest, in case more than one thread actually got in here */
705 if (resultp->aio_return == -1 && resultp->aio_errno == EINVAL) {
706 sig_mutex_unlock(&__aio_mutex);
707 errno = EINVAL;
708 return (-1);
709 }
710 resultp->aio_return = -1;
711 resultp->aio_errno = EINVAL;
712 if ((reqp = _aio_hash_del(resultp)) == NULL)
713 sig_mutex_unlock(&__aio_mutex);
714 else {
715 aiocbp->aio_state = NOCHECK;
716 ASSERT(reqp->req_head == NULL);
717 (void) _aio_req_remove(reqp);
718 sig_mutex_unlock(&__aio_mutex);
719 _aio_req_free(reqp);
720 }
721
722 if (retval == -1)
723 errno = error;
724 return (retval);
725 }
726
727 void
728 _lio_remove(aio_req_t *reqp)
729 {
730 aio_lio_t *head;
731 int refcnt;
732
733 if ((head = reqp->req_head) != NULL) {
734 sig_mutex_lock(&head->lio_mutex);
735 ASSERT(head->lio_refcnt == head->lio_nent);
736 refcnt = --head->lio_nent;
737 head->lio_refcnt--;
738 sig_mutex_unlock(&head->lio_mutex);
739 if (refcnt == 0)
740 _aio_lio_free(head);
741 reqp->req_head = NULL;
742 }
743 }
744
745 /*
746 * This function returns the number of asynchronous I/O requests submitted.
747 */
748 static int
749 __aio_fsync_bar(aiocb_t *aiocbp, aio_lio_t *head, aio_worker_t *aiowp,
750 int workerscnt)
751 {
752 int i;
753 int error;
754 aio_worker_t *next = aiowp;
755
756 for (i = 0; i < workerscnt; i++) {
757 error = _aio_rw(aiocbp, head, &next, AIOFSYNC, AIO_NO_KAIO);
758 if (error != 0) {
759 sig_mutex_lock(&head->lio_mutex);
760 head->lio_mode = LIO_DESTROY; /* ignore fsync */
761 head->lio_nent -= workerscnt - i;
762 head->lio_refcnt -= workerscnt - i;
763 sig_mutex_unlock(&head->lio_mutex);
764 errno = EAGAIN;
765 return (i);
766 }
767 next = next->work_forw;
768 }
769 return (i);
770 }
771
772 int
773 aio_fsync(int op, aiocb_t *aiocbp)
774 {
775 aio_lio_t *head;
776 struct stat statb;
777 int fret;
778
779 if (aiocbp == NULL)
780 return (0);
781 if (op != O_DSYNC && op != O_SYNC) {
782 errno = EINVAL;
783 return (-1);
784 }
785 if (_aio_hash_find(&aiocbp->aio_resultp) != NULL) {
786 errno = EBUSY;
787 return (-1);
788 }
789 if (fstat(aiocbp->aio_fildes, &statb) < 0)
790 return (-1);
791 if (_aio_sigev_thread(aiocbp) != 0)
792 return (-1);
793
794 /*
795 * Kernel aio_fsync() is not supported.
796 * We force user-level aio_fsync() just
797 * for the notification side-effect.
798 */
799 if (!__uaio_ok && __uaio_init() == -1)
800 return (-1);
801
802 /*
803 * The first asynchronous I/O request in the current process will
804 * create a bunch of workers (via __uaio_init()). If the number
805 * of workers is zero then the number of pending asynchronous I/O
806 * requests is zero. In such a case only execute the standard
807 * fsync(3C) or fdatasync(3RT) as appropriate.
808 */
809 if (__rw_workerscnt == 0) {
810 if (op == O_DSYNC)
811 return (__fdsync(aiocbp->aio_fildes, FDSYNC));
812 else
813 return (__fdsync(aiocbp->aio_fildes, FSYNC));
814 }
815
816 /*
817 * re-use aio_offset as the op field.
818 * O_DSYNC - fdatasync()
819 * O_SYNC - fsync()
820 */
821 aiocbp->aio_offset = op;
822 aiocbp->aio_lio_opcode = AIOFSYNC;
823
824 /*
825 * Create a list of fsync requests. The worker that
826 * gets the last request will do the fsync request.
827 */
828 head = _aio_lio_alloc();
829 if (head == NULL) {
830 errno = EAGAIN;
831 return (-1);
832 }
833 head->lio_mode = LIO_FSYNC;
834 head->lio_nent = head->lio_refcnt = __rw_workerscnt;
835 head->lio_largefile = 0;
836
837 /*
838 * Insert an fsync request on every worker's queue.
839 */
840 fret = __aio_fsync_bar(aiocbp, head, __workers_rw, __rw_workerscnt);
841 if (fret != __rw_workerscnt) {
842 /*
843 * Fewer fsync requests than workers means that it was
844 * not possible to submit fsync requests to all workers.
845 * Actions:
846 * a) number of fsync requests submitted is 0:
847 * => free allocated memory (aio_lio_t).
848 * b) number of fsync requests submitted is > 0:
849 * => the last worker executing the fsync request
850 * will free the aio_lio_t struct.
851 */
852 if (fret == 0)
853 _aio_lio_free(head);
854 return (-1);
855 }
856 return (0);
857 }
858
859 int
860 aio_cancel(int fd, aiocb_t *aiocbp)
861 {
862 aio_req_t *reqp;
863 aio_worker_t *aiowp;
864 int done = 0;
865 int canceled = 0;
866 struct stat buf;
867
868 if (fstat(fd, &buf) < 0)
869 return (-1);
870
871 if (aiocbp != NULL) {
872 if (fd != aiocbp->aio_fildes) {
873 errno = EINVAL;
874 return (-1);
875 }
876 if (aiocbp->aio_state == USERAIO) {
877 sig_mutex_lock(&__aio_mutex);
878 reqp = _aio_hash_find(&aiocbp->aio_resultp);
879 if (reqp == NULL) {
880 sig_mutex_unlock(&__aio_mutex);
881 return (AIO_ALLDONE);
882 }
883 aiowp = reqp->req_worker;
884 sig_mutex_lock(&aiowp->work_qlock1);
885 (void) _aio_cancel_req(aiowp, reqp, &canceled, &done);
886 sig_mutex_unlock(&aiowp->work_qlock1);
887 sig_mutex_unlock(&__aio_mutex);
888 if (done)
889 return (AIO_ALLDONE);
890 if (canceled)
891 return (AIO_CANCELED);
892 return (AIO_NOTCANCELED);
893 }
894 if (aiocbp->aio_state == USERAIO_DONE)
895 return (AIO_ALLDONE);
896 return ((int)_kaio(AIOCANCEL, fd, aiocbp));
897 }
898
899 return (aiocancel_all(fd));
900 }
901
902 /*
903 * __aio_waitn() cancellation handler.
904 */
905 /* ARGSUSED */
906 static void
907 _aio_waitn_cleanup(void *arg)
908 {
909 ASSERT(MUTEX_HELD(&__aio_mutex));
910
911 /* check for pending aio_waitn() calls */
912 _aio_flags &= ~(AIO_LIB_WAITN | AIO_WAIT_INPROGRESS | AIO_IO_WAITING);
913 if (_aio_flags & AIO_LIB_WAITN_PENDING) {
914 _aio_flags &= ~AIO_LIB_WAITN_PENDING;
915 (void) cond_signal(&_aio_waitn_cv);
916 }
917
918 sig_mutex_unlock(&__aio_mutex);
919 }
920
921 /*
922 * aio_waitn can be used to reap the results of several I/O operations that
923 * were submitted asynchronously. The submission of I/Os can be done using
924 * existing POSIX interfaces: lio_listio, aio_write or aio_read.
925 * aio_waitn waits until "nwait" I/Os (supplied as a parameter) have
926 * completed and it returns the descriptors for these I/Os in "list". The
927 * maximum size of this list is given by "nent" and the actual number of I/Os
928 * completed is returned in "nwait". Otherwise aio_waitn might also
929 * return if the timeout expires. Additionally, aio_waitn returns 0 if
930 * successful or -1 if an error occurred.
931 */
932 static int
933 __aio_waitn(void **list, uint_t nent, uint_t *nwait, const timespec_t *utimo)
934 {
935 int error = 0;
936 uint_t dnwait = 0; /* amount of requests in the waitn-done list */
937 uint_t kwaitcnt; /* expected "done" requests from kernel */
938 uint_t knentcnt; /* max. expected "done" requests from kernel */
939 int uerrno = 0;
940 int kerrno = 0; /* save errno from _kaio() call */
941 int timedwait = AIO_TIMEOUT_UNDEF;
942 aio_req_t *reqp;
943 timespec_t end;
944 timespec_t twait; /* copy of utimo for internal calculations */
945 timespec_t *wait = NULL;
946
947 if (nent == 0 || *nwait == 0 || *nwait > nent) {
948 errno = EINVAL;
949 return (-1);
950 }
951
952 /*
953 * Only one running aio_waitn call per process allowed.
954 * Further calls will be blocked here until the running
955 * call finishes.
956 */
957
958 sig_mutex_lock(&__aio_mutex);
959
960 while (_aio_flags & AIO_LIB_WAITN) {
961 if (utimo && utimo->tv_sec == 0 && utimo->tv_nsec == 0) {
962 sig_mutex_unlock(&__aio_mutex);
963 *nwait = 0;
964 return (0);
965 }
966 _aio_flags |= AIO_LIB_WAITN_PENDING;
967 pthread_cleanup_push(sig_mutex_unlock, &__aio_mutex);
968 error = sig_cond_wait(&_aio_waitn_cv, &__aio_mutex);
969 pthread_cleanup_pop(0);
970 if (error != 0) {
971 sig_mutex_unlock(&__aio_mutex);
972 *nwait = 0;
973 errno = error;
974 return (-1);
975 }
976 }
977
978 pthread_cleanup_push(_aio_waitn_cleanup, NULL);
979
980 _aio_flags |= AIO_LIB_WAITN;
981
982 if (_aio_check_timeout(utimo, &end, &timedwait) != 0) {
983 error = -1;
984 dnwait = 0;
985 goto out;
986 }
987 if (timedwait != AIO_TIMEOUT_INDEF) {
988 twait = *utimo;
989 wait = &twait;
990 }
991
992 /*
993 * If both counters are still set to zero, then only
994 * kernel requests are currently outstanding (raw-I/Os).
995 */
996 if ((_aio_doneq_cnt + _aio_outstand_cnt) == 0) {
997 for (;;) {
998 kwaitcnt = *nwait - dnwait;
999 knentcnt = nent - dnwait;
1000 if (knentcnt > AIO_WAITN_MAXIOCBS)
1001 knentcnt = AIO_WAITN_MAXIOCBS;
1002 kwaitcnt = (kwaitcnt > knentcnt) ? knentcnt : kwaitcnt;
1003
1004 pthread_cleanup_push(sig_mutex_lock, &__aio_mutex);
1005 sig_mutex_unlock(&__aio_mutex);
1006 _cancel_prologue();
1007 error = (int)_kaio(AIOWAITN, &list[dnwait], knentcnt,
1008 &kwaitcnt, wait);
1009 _cancel_epilogue();
1010 pthread_cleanup_pop(1);
1011
1012 if (error == 0) {
1013 dnwait += kwaitcnt;
1014 if (dnwait >= *nwait ||
1015 *nwait < AIO_WAITN_MAXIOCBS)
1016 break;
1017 if (timedwait == AIO_TIMEOUT_WAIT) {
1018 error = _aio_get_timedelta(&end, wait);
1019 if (error == -1) {
1020 /* timer expired */
1021 errno = ETIME;
1022 break;
1023 }
1024 }
1025 continue;
1026 }
1027 if (errno == EAGAIN) {
1028 if (dnwait > 0)
1029 error = 0;
1030 break;
1031 }
1032 if (errno == ETIME || errno == EINTR) {
1033 dnwait += kwaitcnt;
1034 break;
1035 }
1036 /* fatal error */
1037 break;
1038 }
1039
1040 goto out;
1041 }
1042
1043 /* File system I/Os outstanding ... */
1044
1045 if (timedwait == AIO_TIMEOUT_UNDEF) {
1046 if (_aio_check_timeout(utimo, &end, &timedwait) != 0) {
1047 error = -1;
1048 dnwait = 0;
1049 goto out;
1050 }
1051 if (timedwait != AIO_TIMEOUT_INDEF) {
1052 twait = *utimo;
1053 wait = &twait;
1054 }
1055 }
1056
1057 for (;;) {
1058 uint_t sum_reqs;
1059
1060 /*
1061 * Calculate sum of active non RAW-IO requests (sum_reqs).
1062 * If the expected amount of completed requests (*nwait) is
1063 * greater than the calculated sum (sum_reqs) then
1064 * use _kaio to check pending RAW-IO requests.
1065 */
1066 sum_reqs = _aio_doneq_cnt + dnwait + _aio_outstand_cnt;
1067 kwaitcnt = (*nwait > sum_reqs) ? *nwait - sum_reqs : 0;
1068
1069 if (kwaitcnt != 0) {
1070 /* possibly some kernel I/Os outstanding */
1071 knentcnt = nent - dnwait;
1072 if (knentcnt > AIO_WAITN_MAXIOCBS)
1073 knentcnt = AIO_WAITN_MAXIOCBS;
1074 kwaitcnt = (kwaitcnt > knentcnt) ? knentcnt : kwaitcnt;
1075
1076 _aio_flags |= AIO_WAIT_INPROGRESS;
1077
1078 pthread_cleanup_push(sig_mutex_lock, &__aio_mutex);
1079 sig_mutex_unlock(&__aio_mutex);
1080 _cancel_prologue();
1081 error = (int)_kaio(AIOWAITN, &list[dnwait], knentcnt,
1082 &kwaitcnt, wait);
1083 _cancel_epilogue();
1084 pthread_cleanup_pop(1);
1085
1086 _aio_flags &= ~AIO_WAIT_INPROGRESS;
1087
1088 if (error == 0) {
1089 dnwait += kwaitcnt;
1090 } else {
1091 switch (errno) {
1092 case EINVAL:
1093 case EAGAIN:
1094 /* don't wait for kernel I/Os */
1095 kerrno = 0; /* ignore _kaio() errno */
1096 *nwait = _aio_doneq_cnt +
1097 _aio_outstand_cnt + dnwait;
1098 error = 0;
1099 break;
1100 case EINTR:
1101 case ETIME:
1102 /* just scan for completed LIB I/Os */
1103 dnwait += kwaitcnt;
1104 timedwait = AIO_TIMEOUT_POLL;
1105 kerrno = errno; /* save _kaio() errno */
1106 error = 0;
1107 break;
1108 default:
1109 kerrno = errno; /* save _kaio() errno */
1110 break;
1111 }
1112 }
1113 if (error)
1114 break; /* fatal kernel error */
1115 }
1116
1117 /* check completed FS requests in the "done" queue */
1118
1119 while (_aio_doneq_cnt && dnwait < nent) {
1120 /* get done requests */
1121 if ((reqp = _aio_req_remove(NULL)) != NULL) {
1122 (void) _aio_hash_del(reqp->req_resultp);
1123 list[dnwait++] = reqp->req_aiocbp;
1124 _aio_req_mark_done(reqp);
1125 _lio_remove(reqp);
1126 _aio_req_free(reqp);
1127 }
1128 }
1129
1130 if (dnwait >= *nwait) {
1131 /* min. requested amount of completed I/Os satisfied */
1132 break;
1133 }
1134 if (timedwait == AIO_TIMEOUT_WAIT &&
1135 (error = _aio_get_timedelta(&end, wait)) == -1) {
1136 /* timer expired */
1137 uerrno = ETIME;
1138 break;
1139 }
1140
1141 /*
1142 * If some I/Os are outstanding and we have to wait for them,
1143 * then sleep here. _aiodone() will call _aio_waitn_wakeup()
1144 * to wakeup this thread as soon as the required amount of
1145 * completed I/Os is done.
1146 */
1147 if (_aio_outstand_cnt > 0 && timedwait != AIO_TIMEOUT_POLL) {
1148 /*
1149 * _aio_waitn_wakeup() will wake up this thread when:
1150 * - _aio_waitncnt requests are completed or
1151 * - _aio_outstand_cnt becomes zero.
1152 * sig_cond_reltimedwait() could also return with
1153 * a timeout error (ETIME).
1154 */
1155 if (*nwait < _aio_outstand_cnt)
1156 _aio_waitncnt = *nwait;
1157 else
1158 _aio_waitncnt = _aio_outstand_cnt;
1159
1160 _aio_flags |= AIO_IO_WAITING;
1161
1162 if (wait)
1163 uerrno = sig_cond_reltimedwait(&_aio_iowait_cv,
1164 &__aio_mutex, wait);
1165 else
1166 uerrno = sig_cond_wait(&_aio_iowait_cv,
1167 &__aio_mutex);
1168
1169 _aio_flags &= ~AIO_IO_WAITING;
1170
1171 if (uerrno == ETIME) {
1172 timedwait = AIO_TIMEOUT_POLL;
1173 continue;
1174 }
1175 if (uerrno != 0)
1176 timedwait = AIO_TIMEOUT_POLL;
1177 }
1178
1179 if (timedwait == AIO_TIMEOUT_POLL) {
1180 /* polling or timer expired */
1181 break;
1182 }
1183 }
1184
1185 errno = uerrno == 0 ? kerrno : uerrno;
1186 if (errno)
1187 error = -1;
1188 else
1189 error = 0;
1190
1191 out:
1192 *nwait = dnwait;
1193
1194 pthread_cleanup_pop(1); /* drops __aio_mutex */
1195
1196 return (error);
1197 }
1198
1199 int
1200 aio_waitn(aiocb_t *list[], uint_t nent, uint_t *nwait,
1201 const timespec_t *timeout)
1202 {
1203 return (__aio_waitn((void **)list, nent, nwait, timeout));
1204 }
1205
1206 void
1207 _aio_waitn_wakeup(void)
1208 {
1209 /*
1210 * __aio_waitn() sets AIO_IO_WAITING to notify _aiodone() that
1211 * it is waiting for completed I/Os. The number of required
1212 * completed I/Os is stored into "_aio_waitncnt".
1213 * aio_waitn() is woken up when
1214 * - there are no further outstanding I/Os
1215 * (_aio_outstand_cnt == 0) or
1216 * - the expected number of I/Os has completed.
1217 * Only one __aio_waitn() function waits for completed I/Os at
1218 * a time.
1219 *
1220 * __aio_suspend() increments "_aio_suscv_cnt" to notify
1221 * _aiodone() that at least one __aio_suspend() call is
1222 * waiting for completed I/Os.
1223 * There could be more than one __aio_suspend() function
1224 * waiting for completed I/Os. Because every function should
1225 * be waiting for different I/Os, _aiodone() has to wake up all
1226 * __aio_suspend() functions each time.
1227 * Every __aio_suspend() function will compare the recently
1228 * completed I/O with its own list.
1229 */
1230 ASSERT(MUTEX_HELD(&__aio_mutex));
1231 if (_aio_flags & AIO_IO_WAITING) {
1232 if (_aio_waitncnt > 0)
1233 _aio_waitncnt--;
1234 if (_aio_outstand_cnt == 0 || _aio_waitncnt == 0 ||
1235 _aio_suscv_cnt > 0)
1236 (void) cond_broadcast(&_aio_iowait_cv);
1237 } else {
1238 /* Wake up waiting aio_suspend calls */
1239 if (_aio_suscv_cnt > 0)
1240 (void) cond_broadcast(&_aio_iowait_cv);
1241 }
1242 }
1243
1244 /*
1245 * timedwait values :
1246 * AIO_TIMEOUT_POLL : polling
1247 * AIO_TIMEOUT_WAIT : timeout
1248 * AIO_TIMEOUT_INDEF : wait indefinitely
1249 */
1250 static int
1251 _aio_check_timeout(const timespec_t *utimo, timespec_t *end, int *timedwait)
1252 {
1253 struct timeval curtime;
1254
1255 if (utimo) {
1256 if (utimo->tv_sec < 0 || utimo->tv_nsec < 0 ||
1257 utimo->tv_nsec >= NANOSEC) {
1258 errno = EINVAL;
1259 return (-1);
1260 }
1261 if (utimo->tv_sec > 0 || utimo->tv_nsec > 0) {
1262 (void) gettimeofday(&curtime, NULL);
1263 end->tv_sec = utimo->tv_sec + curtime.tv_sec;
1264 end->tv_nsec = utimo->tv_nsec + 1000 * curtime.tv_usec;
1265 if (end->tv_nsec >= NANOSEC) {
1266 end->tv_nsec -= NANOSEC;
1267 end->tv_sec += 1;
1268 }
1269 *timedwait = AIO_TIMEOUT_WAIT;
1270 } else {
1271 /* polling */
1272 *timedwait = AIO_TIMEOUT_POLL;
1273 }
1274 } else {
1275 *timedwait = AIO_TIMEOUT_INDEF; /* wait indefinitely */
1276 }
1277 return (0);
1278 }
1279
1280 #if !defined(_LP64)
1281
1282 int
1283 aio_read64(aiocb64_t *aiocbp)
1284 {
1285 if (aiocbp == NULL || aiocbp->aio_reqprio != 0) {
1286 errno = EINVAL;
1287 return (-1);
1288 }
1289 if (_aio_hash_find(&aiocbp->aio_resultp) != NULL) {
1290 errno = EBUSY;
1291 return (-1);
1292 }
1293 if (_aio_sigev_thread64(aiocbp) != 0)
1294 return (-1);
1295 aiocbp->aio_lio_opcode = LIO_READ;
1296 return (_aio_rw64(aiocbp, NULL, &__nextworker_rw, AIOAREAD64,
1297 (AIO_KAIO | AIO_NO_DUPS)));
1298 }
1299
1300 int
1301 aio_write64(aiocb64_t *aiocbp)
1302 {
1303 if (aiocbp == NULL || aiocbp->aio_reqprio != 0) {
1304 errno = EINVAL;
1305 return (-1);
1306 }
1307 if (_aio_hash_find(&aiocbp->aio_resultp) != NULL) {
1308 errno = EBUSY;
1309 return (-1);
1310 }
1311 if (_aio_sigev_thread64(aiocbp) != 0)
1312 return (-1);
1313 aiocbp->aio_lio_opcode = LIO_WRITE;
1314 return (_aio_rw64(aiocbp, NULL, &__nextworker_rw, AIOAWRITE64,
1315 (AIO_KAIO | AIO_NO_DUPS)));
1316 }
1317
1318 int
1319 lio_listio64(int mode, aiocb64_t *_RESTRICT_KYWD const *_RESTRICT_KYWD list,
1320 int nent, struct sigevent *_RESTRICT_KYWD sigevp)
1321 {
1322 int aio_ufs = 0;
1323 int oerrno = 0;
1324 aio_lio_t *head = NULL;
1325 aiocb64_t *aiocbp;
1326 int state = 0;
1327 int EIOflg = 0;
1328 int rw;
1329 int do_kaio = 0;
1330 int error;
1331 int i;
1332
1333 if (!_kaio_ok)
1334 _kaio_init();
1335
1336 if (aio_list_max == 0)
1337 aio_list_max = sysconf(_SC_AIO_LISTIO_MAX);
1338
1339 if (nent <= 0 || nent > aio_list_max) {
1340 errno = EINVAL;
1341 return (-1);
1342 }
1343
1344 switch (mode) {
1345 case LIO_WAIT:
1346 state = NOCHECK;
1347 break;
1348 case LIO_NOWAIT:
1349 state = CHECK;
1350 break;
1351 default:
1352 errno = EINVAL;
1353 return (-1);
1354 }
1355
1356 for (i = 0; i < nent; i++) {
1357 if ((aiocbp = list[i]) == NULL)
1358 continue;
1359 if (_aio_hash_find(&aiocbp->aio_resultp) != NULL) {
1360 errno = EBUSY;
1361 return (-1);
1362 }
1363 if (_aio_sigev_thread64(aiocbp) != 0)
1364 return (-1);
1365 if (aiocbp->aio_lio_opcode == LIO_NOP)
1366 aiocbp->aio_state = NOCHECK;
1367 else {
1368 aiocbp->aio_state = state;
1369 if (KAIO_SUPPORTED(aiocbp->aio_fildes))
1370 do_kaio++;
1371 else
1372 aiocbp->aio_resultp.aio_errno = ENOTSUP;
1373 }
1374 }
1375 if (_aio_sigev_thread_init(sigevp) != 0)
1376 return (-1);
1377
1378 if (do_kaio) {
1379 error = (int)_kaio(AIOLIO64, mode, list, nent, sigevp);
1380 if (error == 0)
1381 return (0);
1382 oerrno = errno;
1383 } else {
1384 oerrno = errno = ENOTSUP;
1385 error = -1;
1386 }
1387
1388 if (error == -1 && errno == ENOTSUP) {
1389 error = errno = 0;
1390 /*
1391 * If LIO_WAIT, or notification required, allocate a list head.
1392 */
1393 if (mode == LIO_WAIT ||
1394 (sigevp != NULL &&
1395 (sigevp->sigev_notify == SIGEV_SIGNAL ||
1396 sigevp->sigev_notify == SIGEV_THREAD ||
1397 sigevp->sigev_notify == SIGEV_PORT)))
1398 head = _aio_lio_alloc();
1399 if (head) {
1400 sig_mutex_lock(&head->lio_mutex);
1401 head->lio_mode = mode;
1402 head->lio_largefile = 1;
1403 if (mode == LIO_NOWAIT && sigevp != NULL) {
1404 if (sigevp->sigev_notify == SIGEV_THREAD) {
1405 head->lio_port = sigevp->sigev_signo;
1406 head->lio_event = AIOLIO64;
1407 head->lio_sigevent = sigevp;
1408 head->lio_sigval.sival_ptr =
1409 sigevp->sigev_value.sival_ptr;
1410 } else if (sigevp->sigev_notify == SIGEV_PORT) {
1411 port_notify_t *pn =
1412 sigevp->sigev_value.sival_ptr;
1413 head->lio_port = pn->portnfy_port;
1414 head->lio_event = AIOLIO64;
1415 head->lio_sigevent = sigevp;
1416 head->lio_sigval.sival_ptr =
1417 pn->portnfy_user;
1418 } else { /* SIGEV_SIGNAL */
1419 head->lio_signo = sigevp->sigev_signo;
1420 head->lio_sigval.sival_ptr =
1421 sigevp->sigev_value.sival_ptr;
1422 }
1423 }
1424 head->lio_nent = head->lio_refcnt = nent;
1425 sig_mutex_unlock(&head->lio_mutex);
1426 }
1427 /*
1428 * find UFS requests, errno == ENOTSUP/EBADFD,
1429 */
1430 for (i = 0; i < nent; i++) {
1431 if ((aiocbp = list[i]) == NULL ||
1432 aiocbp->aio_lio_opcode == LIO_NOP ||
1433 (aiocbp->aio_resultp.aio_errno != ENOTSUP &&
1434 aiocbp->aio_resultp.aio_errno != EBADFD)) {
1435 if (head)
1436 _lio_list_decr(head);
1437 continue;
1438 }
1439 if (aiocbp->aio_resultp.aio_errno == EBADFD)
1440 SET_KAIO_NOT_SUPPORTED(aiocbp->aio_fildes);
1441 if (aiocbp->aio_reqprio != 0) {
1442 aiocbp->aio_resultp.aio_errno = EINVAL;
1443 aiocbp->aio_resultp.aio_return = -1;
1444 EIOflg = 1;
1445 if (head)
1446 _lio_list_decr(head);
1447 continue;
1448 }
1449 /*
1450 * submit an AIO request with flags AIO_NO_KAIO
1451 * to avoid the kaio() syscall in _aio_rw()
1452 */
1453 switch (aiocbp->aio_lio_opcode) {
1454 case LIO_READ:
1455 rw = AIOAREAD64;
1456 break;
1457 case LIO_WRITE:
1458 rw = AIOAWRITE64;
1459 break;
1460 }
1461 error = _aio_rw64(aiocbp, head, &__nextworker_rw, rw,
1462 (AIO_NO_KAIO | AIO_NO_DUPS));
1463 if (error == 0)
1464 aio_ufs++;
1465 else {
1466 if (head)
1467 _lio_list_decr(head);
1468 aiocbp->aio_resultp.aio_errno = error;
1469 EIOflg = 1;
1470 }
1471 }
1472 }
1473 if (EIOflg) {
1474 errno = EIO;
1475 return (-1);
1476 }
1477 if (mode == LIO_WAIT && oerrno == ENOTSUP) {
1478 /*
1479 * call kaio(AIOLIOWAIT) to get all outstanding
1480 * kernel AIO requests
1481 */
1482 if ((nent - aio_ufs) > 0)
1483 (void) _kaio(AIOLIOWAIT, mode, list, nent, sigevp);
1484 if (head != NULL && head->lio_nent > 0) {
1485 sig_mutex_lock(&head->lio_mutex);
1486 while (head->lio_refcnt > 0) {
1487 int err;
1488 head->lio_waiting = 1;
1489 pthread_cleanup_push(_lio_listio_cleanup, head);
1490 err = sig_cond_wait(&head->lio_cond_cv,
1491 &head->lio_mutex);
1492 pthread_cleanup_pop(0);
1493 head->lio_waiting = 0;
1494 if (err && head->lio_nent > 0) {
1495 sig_mutex_unlock(&head->lio_mutex);
1496 errno = err;
1497 return (-1);
1498 }
1499 }
1500 sig_mutex_unlock(&head->lio_mutex);
1501 ASSERT(head->lio_nent == 0 && head->lio_refcnt == 0);
1502 _aio_lio_free(head);
1503 for (i = 0; i < nent; i++) {
1504 if ((aiocbp = list[i]) != NULL &&
1505 aiocbp->aio_resultp.aio_errno) {
1506 errno = EIO;
1507 return (-1);
1508 }
1509 }
1510 }
1511 return (0);
1512 }
1513 return (error);
1514 }
1515
1516 int
1517 aio_suspend64(const aiocb64_t * const list[], int nent,
1518 const timespec_t *timeout)
1519 {
1520 return (__aio_suspend((void **)list, nent, timeout, 1));
1521 }
1522
1523 int
1524 aio_error64(const aiocb64_t *aiocbp)
1525 {
1526 const aio_result_t *resultp = &aiocbp->aio_resultp;
1527 int error;
1528
1529 if ((error = resultp->aio_errno) == EINPROGRESS) {
1530 if (aiocbp->aio_state == CHECK) {
1531 /*
1532 * Always do the kaio() call without using the
1533 * KAIO_SUPPORTED() checks because it is not
1534 * mandatory to have a valid fd set in the
1535 * aiocb, only the resultp must be set.
1536 */
1537 if ((int)_kaio(AIOERROR64, aiocbp) == EINVAL) {
1538 errno = EINVAL;
1539 return (-1);
1540 }
1541 error = resultp->aio_errno;
1542 } else if (aiocbp->aio_state == CHECKED) {
1543 ((aiocb64_t *)aiocbp)->aio_state = CHECK;
1544 }
1545 }
1546 return (error);
1547 }
1548
1549 ssize_t
1550 aio_return64(aiocb64_t *aiocbp)
1551 {
1552 aio_result_t *resultp = &aiocbp->aio_resultp;
1553 aio_req_t *reqp;
1554 int error;
1555 ssize_t retval;
1556
1557 /*
1558 * The _aiodone() function stores resultp->aio_return before
1559 * storing resultp->aio_errno (with an membar_producer() in
1560 * between). We use membar_consumer() below to ensure proper
1561 * memory ordering between _aiodone() and ourself.
1562 */
1563 error = resultp->aio_errno;
1564 membar_consumer();
1565 retval = resultp->aio_return;
1566
1567 /*
1568 * we use this condition to indicate either that
1569 * aio_return() has been called before or should
1570 * not have been called yet.
1571 */
1572 if ((retval == -1 && error == EINVAL) || error == EINPROGRESS) {
1573 errno = error;
1574 return (-1);
1575 }
1576
1577 /*
1578 * Before we return, mark the result as being returned so that later
1579 * calls to aio_return() will return the fact that the result has
1580 * already been returned.
1581 */
1582 sig_mutex_lock(&__aio_mutex);
1583 /* retest, in case more than one thread actually got in here */
1584 if (resultp->aio_return == -1 && resultp->aio_errno == EINVAL) {
1585 sig_mutex_unlock(&__aio_mutex);
1586 errno = EINVAL;
1587 return (-1);
1588 }
1589 resultp->aio_return = -1;
1590 resultp->aio_errno = EINVAL;
1591 if ((reqp = _aio_hash_del(resultp)) == NULL)
1592 sig_mutex_unlock(&__aio_mutex);
1593 else {
1594 aiocbp->aio_state = NOCHECK;
1595 ASSERT(reqp->req_head == NULL);
1596 (void) _aio_req_remove(reqp);
1597 sig_mutex_unlock(&__aio_mutex);
1598 _aio_req_free(reqp);
1599 }
1600
1601 if (retval == -1)
1602 errno = error;
1603 return (retval);
1604 }
1605
1606 static int
1607 __aio_fsync_bar64(aiocb64_t *aiocbp, aio_lio_t *head, aio_worker_t *aiowp,
1608 int workerscnt)
1609 {
1610 int i;
1611 int error;
1612 aio_worker_t *next = aiowp;
1613
1614 for (i = 0; i < workerscnt; i++) {
1615 error = _aio_rw64(aiocbp, head, &next, AIOFSYNC, AIO_NO_KAIO);
1616 if (error != 0) {
1617 sig_mutex_lock(&head->lio_mutex);
1618 head->lio_mode = LIO_DESTROY; /* ignore fsync */
1619 head->lio_nent -= workerscnt - i;
1620 head->lio_refcnt -= workerscnt - i;
1621 sig_mutex_unlock(&head->lio_mutex);
1622 errno = EAGAIN;
1623 return (i);
1624 }
1625 next = next->work_forw;
1626 }
1627 return (i);
1628 }
1629
1630 int
1631 aio_fsync64(int op, aiocb64_t *aiocbp)
1632 {
1633 aio_lio_t *head;
1634 struct stat64 statb;
1635 int fret;
1636
1637 if (aiocbp == NULL)
1638 return (0);
1639 if (op != O_DSYNC && op != O_SYNC) {
1640 errno = EINVAL;
1641 return (-1);
1642 }
1643 if (_aio_hash_find(&aiocbp->aio_resultp) != NULL) {
1644 errno = EBUSY;
1645 return (-1);
1646 }
1647 if (fstat64(aiocbp->aio_fildes, &statb) < 0)
1648 return (-1);
1649 if (_aio_sigev_thread64(aiocbp) != 0)
1650 return (-1);
1651
1652 /*
1653 * Kernel aio_fsync() is not supported.
1654 * We force user-level aio_fsync() just
1655 * for the notification side-effect.
1656 */
1657 if (!__uaio_ok && __uaio_init() == -1)
1658 return (-1);
1659
1660 /*
1661 * The first asynchronous I/O request in the current process will
1662 * create a bunch of workers (via __uaio_init()). If the number
1663 * of workers is zero then the number of pending asynchronous I/O
1664 * requests is zero. In such a case only execute the standard
1665 * fsync(3C) or fdatasync(3RT) as appropriate.
1666 */
1667 if (__rw_workerscnt == 0) {
1668 if (op == O_DSYNC)
1669 return (__fdsync(aiocbp->aio_fildes, FDSYNC));
1670 else
1671 return (__fdsync(aiocbp->aio_fildes, FSYNC));
1672 }
1673
1674 /*
1675 * re-use aio_offset as the op field.
1676 * O_DSYNC - fdatasync()
1677 * O_SYNC - fsync()
1678 */
1679 aiocbp->aio_offset = op;
1680 aiocbp->aio_lio_opcode = AIOFSYNC;
1681
1682 /*
1683 * Create a list of fsync requests. The worker that
1684 * gets the last request will do the fsync request.
1685 */
1686 head = _aio_lio_alloc();
1687 if (head == NULL) {
1688 errno = EAGAIN;
1689 return (-1);
1690 }
1691 head->lio_mode = LIO_FSYNC;
1692 head->lio_nent = head->lio_refcnt = __rw_workerscnt;
1693 head->lio_largefile = 1;
1694
1695 /*
1696 * Insert an fsync request on every worker's queue.
1697 */
1698 fret = __aio_fsync_bar64(aiocbp, head, __workers_rw, __rw_workerscnt);
1699 if (fret != __rw_workerscnt) {
1700 /*
1701 * Fewer fsync requests than workers means that it was
1702 * not possible to submit fsync requests to all workers.
1703 * Actions:
1704 * a) number of fsync requests submitted is 0:
1705 * => free allocated memory (aio_lio_t).
1706 * b) number of fsync requests submitted is > 0:
1707 * => the last worker executing the fsync request
1708 * will free the aio_lio_t struct.
1709 */
1710 if (fret == 0)
1711 _aio_lio_free(head);
1712 return (-1);
1713 }
1714 return (0);
1715 }
1716
1717 int
1718 aio_cancel64(int fd, aiocb64_t *aiocbp)
1719 {
1720 aio_req_t *reqp;
1721 aio_worker_t *aiowp;
1722 int done = 0;
1723 int canceled = 0;
1724 struct stat64 buf;
1725
1726 if (fstat64(fd, &buf) < 0)
1727 return (-1);
1728
1729 if (aiocbp != NULL) {
1730 if (fd != aiocbp->aio_fildes) {
1731 errno = EINVAL;
1732 return (-1);
1733 }
1734 if (aiocbp->aio_state == USERAIO) {
1735 sig_mutex_lock(&__aio_mutex);
1736 reqp = _aio_hash_find(&aiocbp->aio_resultp);
1737 if (reqp == NULL) {
1738 sig_mutex_unlock(&__aio_mutex);
1739 return (AIO_ALLDONE);
1740 }
1741 aiowp = reqp->req_worker;
1742 sig_mutex_lock(&aiowp->work_qlock1);
1743 (void) _aio_cancel_req(aiowp, reqp, &canceled, &done);
1744 sig_mutex_unlock(&aiowp->work_qlock1);
1745 sig_mutex_unlock(&__aio_mutex);
1746 if (done)
1747 return (AIO_ALLDONE);
1748 if (canceled)
1749 return (AIO_CANCELED);
1750 return (AIO_NOTCANCELED);
1751 }
1752 if (aiocbp->aio_state == USERAIO_DONE)
1753 return (AIO_ALLDONE);
1754 return ((int)_kaio(AIOCANCEL, fd, aiocbp));
1755 }
1756
1757 return (aiocancel_all(fd));
1758 }
1759
1760 int
1761 aio_waitn64(aiocb64_t *list[], uint_t nent, uint_t *nwait,
1762 const timespec_t *timeout)
1763 {
1764 return (__aio_waitn((void **)list, nent, nwait, timeout));
1765 }
1766
1767 #endif /* !defined(_LP64) */
unleashed repo fork