1 /* Suspend until termination of a requests.
2 Copyright (C) 1997,1998,1999,2000,2002,2003 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, write to the Free
18 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
22 /* We use an UGLY hack to prevent gcc from finding us cheating. The
23 implementations of aio_suspend and aio_suspend64 are identical and so
24 we want to avoid code duplication by using aliases. But gcc sees
25 the different parameter lists and prints a warning. We define here
26 a function so that aio_suspend64 has no prototype. */
27 #define aio_suspend64 XXX
29 /* And undo the hack. */
38 #include <bits/libc-lock.h>
44 const struct aiocb
*const *list
;
45 struct waitlist
*waitlist
;
46 struct requestlist
**requestlist
;
55 const struct clparam
*param
= (const struct clparam
*) arg
;
57 /* Now remove the entry in the waiting list for all requests
58 which didn't terminate. */
59 int cnt
= param
->nent
;
61 if (param
->list
[cnt
] != NULL
62 && param
->list
[cnt
]->__error_code
== EINPROGRESS
)
64 struct waitlist
**listp
;
66 assert (param
->requestlist
[cnt
] != NULL
);
68 /* There is the chance that we cannot find our entry anymore. This
69 could happen if the request terminated and restarted again. */
70 listp
= ¶m
->requestlist
[cnt
]->waiting
;
71 while (*listp
!= NULL
&& *listp
!= ¶m
->waitlist
[cnt
])
72 listp
= &(*listp
)->next
;
75 *listp
= (*listp
)->next
;
78 /* Release the conditional variable. */
79 (void) pthread_cond_destroy (param
->cond
);
81 /* Release the mutex. */
82 pthread_mutex_unlock (&__aio_requests_mutex
);
87 aio_suspend (list
, nent
, timeout
)
88 const struct aiocb
*const list
[];
90 const struct timespec
*timeout
;
92 struct waitlist waitlist
[nent
];
93 struct requestlist
*requestlist
[nent
];
94 pthread_cond_t cond
= PTHREAD_COND_INITIALIZER
;
100 /* Request the mutex. */
101 pthread_mutex_lock (&__aio_requests_mutex
);
103 /* There is not yet a finished request. Signal the request that
104 we are working for it. */
105 for (cnt
= 0; cnt
< nent
; ++cnt
)
106 if (list
[cnt
] != NULL
)
108 if (list
[cnt
]->__error_code
== EINPROGRESS
)
110 requestlist
[cnt
] = __aio_find_req ((aiocb_union
*) list
[cnt
]);
112 if (requestlist
[cnt
] != NULL
)
114 waitlist
[cnt
].cond
= &cond
;
115 waitlist
[cnt
].next
= requestlist
[cnt
]->waiting
;
116 waitlist
[cnt
].counterp
= &dummy
;
117 waitlist
[cnt
].sigevp
= NULL
;
118 #ifdef BROKEN_THREAD_SIGNALS
119 waitlist
[cnt
].caller_pid
= 0; /* Not needed. */
121 requestlist
[cnt
]->waiting
= &waitlist
[cnt
];
125 /* We will never suspend. */
129 /* We will never suspend. */
134 /* Only if none of the entries is NULL or finished to be wait. */
135 if (cnt
== nent
&& any
)
137 struct clparam clparam
=
140 .waitlist
= waitlist
,
141 .requestlist
= requestlist
,
146 pthread_cleanup_push (cleanup
, &clparam
);
149 result
= pthread_cond_wait (&cond
, &__aio_requests_mutex
);
152 /* We have to convert the relative timeout value into an
153 absolute time value with pthread_cond_timedwait expects. */
155 struct timespec abstime
;
157 __gettimeofday (&now
, NULL
);
158 abstime
.tv_nsec
= timeout
->tv_nsec
+ now
.tv_usec
* 1000;
159 abstime
.tv_sec
= timeout
->tv_sec
+ now
.tv_sec
;
160 if (abstime
.tv_nsec
>= 1000000000)
162 abstime
.tv_nsec
-= 1000000000;
166 result
= pthread_cond_timedwait (&cond
, &__aio_requests_mutex
,
170 pthread_cleanup_pop (0);
173 /* Now remove the entry in the waiting list for all requests
174 which didn't terminate. */
176 if (list
[cnt
] != NULL
&& list
[cnt
]->__error_code
== EINPROGRESS
)
178 struct waitlist
**listp
;
180 assert (requestlist
[cnt
] != NULL
);
182 /* There is the chance that we cannot find our entry anymore. This
183 could happen if the request terminated and restarted again. */
184 listp
= &requestlist
[cnt
]->waiting
;
185 while (*listp
!= NULL
&& *listp
!= &waitlist
[cnt
])
186 listp
= &(*listp
)->next
;
189 *listp
= (*listp
)->next
;
192 /* Release the conditional variable. */
193 if (__builtin_expect (pthread_cond_destroy (&cond
) != 0, 0))
194 /* This must never happen. */
199 /* An error occurred. Possibly it's EINTR. We have to translate
200 the timeout error report of `pthread_cond_timedwait' to the
201 form expected from `aio_suspend'. */
202 if (result
== ETIMEDOUT
)
203 __set_errno (EAGAIN
);
205 __set_errno (result
);
210 /* Release the mutex. */
211 pthread_mutex_unlock (&__aio_requests_mutex
);
216 weak_alias (aio_suspend
, aio_suspend64
)