]>
Commit | Line | Data |
---|---|---|
cbdee279 | 1 | /* Suspend until termination of a requests. |
b168057a | 2 | Copyright (C) 1997-2015 Free Software Foundation, Inc. |
cbdee279 UD |
3 | This file is part of the GNU C Library. |
4 | Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997. | |
5 | ||
6 | The GNU C Library is free software; you can redistribute it and/or | |
41bdb6e2 AJ |
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. | |
cbdee279 UD |
10 | |
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 | |
41bdb6e2 | 14 | Lesser General Public License for more details. |
cbdee279 | 15 | |
41bdb6e2 | 16 | You should have received a copy of the GNU Lesser General Public |
59ba27a6 PE |
17 | License along with the GNU C Library; if not, see |
18 | <http://www.gnu.org/licenses/>. */ | |
cbdee279 UD |
19 | |
20 | ||
21 | /* We use an UGLY hack to prevent gcc from finding us cheating. The | |
f14811c7 | 22 | implementations of aio_suspend and aio_suspend64 are identical and so |
cbdee279 UD |
23 | we want to avoid code duplication by using aliases. But gcc sees |
24 | the different parameter lists and prints a warning. We define here | |
25 | a function so that aio_suspend64 has no prototype. */ | |
26 | #define aio_suspend64 XXX | |
27 | #include <aio.h> | |
28 | /* And undo the hack. */ | |
29 | #undef aio_suspend64 | |
30 | ||
8b8cc76f | 31 | #include <assert.h> |
cbdee279 | 32 | #include <errno.h> |
c547b58a | 33 | #include <stdbool.h> |
3d8e9510 | 34 | #include <stdlib.h> |
f14811c7 | 35 | #include <sys/time.h> |
cbdee279 | 36 | |
60d73a7a | 37 | #include <bits/libc-lock.h> |
8f480b4b | 38 | #include <aio_misc.h> |
cbdee279 UD |
39 | |
40 | ||
60d73a7a UD |
41 | struct clparam |
42 | { | |
43 | const struct aiocb *const *list; | |
44 | struct waitlist *waitlist; | |
45 | struct requestlist **requestlist; | |
679d83ba | 46 | #ifndef DONT_NEED_AIO_MISC_COND |
60d73a7a | 47 | pthread_cond_t *cond; |
679d83ba | 48 | #endif |
60d73a7a UD |
49 | int nent; |
50 | }; | |
51 | ||
52 | ||
53 | static void | |
54 | cleanup (void *arg) | |
55 | { | |
679d83ba UD |
56 | #ifdef DONT_NEED_AIO_MISC_COND |
57 | /* Acquire the mutex. If pthread_cond_*wait is used this would | |
58 | happen implicitly. */ | |
59 | pthread_mutex_lock (&__aio_requests_mutex); | |
60 | #endif | |
61 | ||
60d73a7a UD |
62 | const struct clparam *param = (const struct clparam *) arg; |
63 | ||
64 | /* Now remove the entry in the waiting list for all requests | |
65 | which didn't terminate. */ | |
66 | int cnt = param->nent; | |
67 | while (cnt-- > 0) | |
68 | if (param->list[cnt] != NULL | |
69 | && param->list[cnt]->__error_code == EINPROGRESS) | |
70 | { | |
71 | struct waitlist **listp; | |
72 | ||
73 | assert (param->requestlist[cnt] != NULL); | |
74 | ||
75 | /* There is the chance that we cannot find our entry anymore. This | |
76 | could happen if the request terminated and restarted again. */ | |
77 | listp = ¶m->requestlist[cnt]->waiting; | |
78 | while (*listp != NULL && *listp != ¶m->waitlist[cnt]) | |
79 | listp = &(*listp)->next; | |
80 | ||
81 | if (*listp != NULL) | |
82 | *listp = (*listp)->next; | |
83 | } | |
84 | ||
679d83ba | 85 | #ifndef DONT_NEED_AIO_MISC_COND |
60d73a7a UD |
86 | /* Release the conditional variable. */ |
87 | (void) pthread_cond_destroy (param->cond); | |
679d83ba | 88 | #endif |
60d73a7a UD |
89 | |
90 | /* Release the mutex. */ | |
91 | pthread_mutex_unlock (&__aio_requests_mutex); | |
92 | } | |
93 | ||
22044b48 DM |
94 | #ifdef DONT_NEED_AIO_MISC_COND |
95 | static int | |
96 | __attribute__ ((noinline)) | |
97 | do_aio_misc_wait(int *cntr, const struct timespec *timeout) | |
98 | { | |
99 | int result = 0; | |
100 | ||
101 | AIO_MISC_WAIT(result, *cntr, timeout, 1); | |
102 | ||
103 | return result; | |
104 | } | |
105 | #endif | |
60d73a7a | 106 | |
cbdee279 UD |
107 | int |
108 | aio_suspend (list, nent, timeout) | |
109 | const struct aiocb *const list[]; | |
110 | int nent; | |
111 | const struct timespec *timeout; | |
112 | { | |
a1ffb40e | 113 | if (__glibc_unlikely (nent < 0)) |
679d83ba UD |
114 | { |
115 | __set_errno (EINVAL); | |
116 | return -1; | |
117 | } | |
118 | ||
d71b808a UD |
119 | struct waitlist waitlist[nent]; |
120 | struct requestlist *requestlist[nent]; | |
679d83ba | 121 | #ifndef DONT_NEED_AIO_MISC_COND |
18de8c73 | 122 | pthread_cond_t cond = PTHREAD_COND_INITIALIZER; |
679d83ba | 123 | #endif |
cbdee279 | 124 | int cnt; |
c547b58a | 125 | bool any = false; |
d71b808a | 126 | int result = 0; |
679d83ba | 127 | int cntr = 1; |
d71b808a UD |
128 | |
129 | /* Request the mutex. */ | |
130 | pthread_mutex_lock (&__aio_requests_mutex); | |
cbdee279 | 131 | |
b9337b6a UD |
132 | /* There is not yet a finished request. Signal the request that |
133 | we are working for it. */ | |
cbdee279 | 134 | for (cnt = 0; cnt < nent; ++cnt) |
8b8cc76f | 135 | if (list[cnt] != NULL) |
b9337b6a | 136 | { |
8b8cc76f | 137 | if (list[cnt]->__error_code == EINPROGRESS) |
b9337b6a | 138 | { |
8b8cc76f UD |
139 | requestlist[cnt] = __aio_find_req ((aiocb_union *) list[cnt]); |
140 | ||
141 | if (requestlist[cnt] != NULL) | |
142 | { | |
679d83ba | 143 | #ifndef DONT_NEED_AIO_MISC_COND |
8b8cc76f | 144 | waitlist[cnt].cond = &cond; |
679d83ba | 145 | #endif |
9759bbf1 | 146 | waitlist[cnt].result = NULL; |
8b8cc76f | 147 | waitlist[cnt].next = requestlist[cnt]->waiting; |
679d83ba | 148 | waitlist[cnt].counterp = &cntr; |
8b8cc76f | 149 | waitlist[cnt].sigevp = NULL; |
b61c8aba | 150 | #ifdef BROKEN_THREAD_SIGNALS |
8b8cc76f | 151 | waitlist[cnt].caller_pid = 0; /* Not needed. */ |
b61c8aba | 152 | #endif |
8b8cc76f | 153 | requestlist[cnt]->waiting = &waitlist[cnt]; |
c547b58a | 154 | any = true; |
8b8cc76f UD |
155 | } |
156 | else | |
157 | /* We will never suspend. */ | |
158 | break; | |
b9337b6a | 159 | } |
8b8cc76f UD |
160 | else |
161 | /* We will never suspend. */ | |
162 | break; | |
b9337b6a | 163 | } |
d71b808a | 164 | |
8ee87680 UD |
165 | |
166 | /* Only if none of the entries is NULL or finished to be wait. */ | |
c547b58a | 167 | if (cnt == nent && any) |
d71b808a | 168 | { |
60d73a7a UD |
169 | struct clparam clparam = |
170 | { | |
171 | .list = list, | |
172 | .waitlist = waitlist, | |
173 | .requestlist = requestlist, | |
679d83ba | 174 | #ifndef DONT_NEED_AIO_MISC_COND |
60d73a7a | 175 | .cond = &cond, |
679d83ba | 176 | #endif |
60d73a7a UD |
177 | .nent = nent |
178 | }; | |
d71b808a | 179 | |
67b78ef9 | 180 | pthread_cleanup_push (cleanup, &clparam); |
d71b808a | 181 | |
679d83ba | 182 | #ifdef DONT_NEED_AIO_MISC_COND |
22044b48 | 183 | result = do_aio_misc_wait(&cntr, timeout); |
679d83ba | 184 | #else |
8ee87680 UD |
185 | if (timeout == NULL) |
186 | result = pthread_cond_wait (&cond, &__aio_requests_mutex); | |
187 | else | |
f14811c7 | 188 | { |
8ee87680 UD |
189 | /* We have to convert the relative timeout value into an |
190 | absolute time value with pthread_cond_timedwait expects. */ | |
191 | struct timeval now; | |
192 | struct timespec abstime; | |
193 | ||
194 | __gettimeofday (&now, NULL); | |
195 | abstime.tv_nsec = timeout->tv_nsec + now.tv_usec * 1000; | |
196 | abstime.tv_sec = timeout->tv_sec + now.tv_sec; | |
197 | if (abstime.tv_nsec >= 1000000000) | |
f14811c7 | 198 | { |
8ee87680 UD |
199 | abstime.tv_nsec -= 1000000000; |
200 | abstime.tv_sec += 1; | |
f14811c7 | 201 | } |
8ee87680 UD |
202 | |
203 | result = pthread_cond_timedwait (&cond, &__aio_requests_mutex, | |
204 | &abstime); | |
f14811c7 | 205 | } |
679d83ba | 206 | #endif |
d71b808a | 207 | |
67b78ef9 | 208 | pthread_cleanup_pop (0); |
8ee87680 | 209 | } |
8b8cc76f | 210 | |
8ee87680 UD |
211 | /* Now remove the entry in the waiting list for all requests |
212 | which didn't terminate. */ | |
213 | while (cnt-- > 0) | |
214 | if (list[cnt] != NULL && list[cnt]->__error_code == EINPROGRESS) | |
215 | { | |
216 | struct waitlist **listp; | |
d71b808a | 217 | |
8ee87680 | 218 | assert (requestlist[cnt] != NULL); |
d71b808a | 219 | |
8ee87680 UD |
220 | /* There is the chance that we cannot find our entry anymore. This |
221 | could happen if the request terminated and restarted again. */ | |
222 | listp = &requestlist[cnt]->waiting; | |
223 | while (*listp != NULL && *listp != &waitlist[cnt]) | |
224 | listp = &(*listp)->next; | |
d71b808a | 225 | |
8ee87680 UD |
226 | if (*listp != NULL) |
227 | *listp = (*listp)->next; | |
228 | } | |
d71b808a | 229 | |
679d83ba | 230 | #ifndef DONT_NEED_AIO_MISC_COND |
8ee87680 | 231 | /* Release the conditional variable. */ |
a1ffb40e | 232 | if (__glibc_unlikely (pthread_cond_destroy (&cond) != 0)) |
8ee87680 UD |
233 | /* This must never happen. */ |
234 | abort (); | |
679d83ba | 235 | #endif |
b9337b6a | 236 | |
8ee87680 UD |
237 | if (result != 0) |
238 | { | |
679d83ba UD |
239 | #ifndef DONT_NEED_AIO_MISC_COND |
240 | /* An error occurred. Possibly it's ETIMEDOUT. We have to translate | |
8ee87680 UD |
241 | the timeout error report of `pthread_cond_timedwait' to the |
242 | form expected from `aio_suspend'. */ | |
243 | if (result == ETIMEDOUT) | |
244 | __set_errno (EAGAIN); | |
67b78ef9 | 245 | else |
679d83ba | 246 | #endif |
67b78ef9 | 247 | __set_errno (result); |
d71b808a | 248 | |
8ee87680 | 249 | result = -1; |
d71b808a | 250 | } |
cbdee279 | 251 | |
d71b808a UD |
252 | /* Release the mutex. */ |
253 | pthread_mutex_unlock (&__aio_requests_mutex); | |
cbdee279 | 254 | |
d71b808a | 255 | return result; |
cbdee279 UD |
256 | } |
257 | ||
258 | weak_alias (aio_suspend, aio_suspend64) |