]>
Commit | Line | Data |
---|---|---|
04277e02 | 1 | /* Copyright (C) 2001-2019 Free Software Foundation, Inc. |
2ace5721 UD |
2 | This file is part of the GNU C Library. |
3 | Contributed by Ulrich Drepper <drepper@redhat.com>, 2001. | |
4 | ||
5 | The GNU C Library is free software; you can redistribute it and/or | |
41bdb6e2 AJ |
6 | modify it under the terms of the GNU Lesser General Public |
7 | License as published by the Free Software Foundation; either | |
8 | version 2.1 of the License, or (at your option) any later version. | |
2ace5721 UD |
9 | |
10 | The GNU C Library is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
41bdb6e2 | 13 | Lesser General Public License for more details. |
2ace5721 | 14 | |
41bdb6e2 | 15 | You should have received a copy of the GNU Lesser General Public |
59ba27a6 | 16 | License along with the GNU C Library; if not, see |
5a82c748 | 17 | <https://www.gnu.org/licenses/>. */ |
2ace5721 UD |
18 | |
19 | #include <assert.h> | |
20 | #include <errno.h> | |
21 | #include <pthread.h> | |
22 | #include <stdlib.h> | |
23 | #include <sys/time.h> | |
24 | ||
f1762c0c | 25 | #include <gai_misc.h> |
2ace5721 UD |
26 | |
27 | ||
28 | ||
f1762c0c UD |
29 | #ifndef gai_create_helper_thread |
30 | # define gai_create_helper_thread __gai_create_helper_thread | |
31 | ||
32 | extern inline int | |
33 | __gai_create_helper_thread (pthread_t *threadp, void *(*tf) (void *), | |
34 | void *arg) | |
35 | { | |
36 | pthread_attr_t attr; | |
37 | ||
38 | /* Make sure the thread is created detached. */ | |
39 | pthread_attr_init (&attr); | |
40 | pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED); | |
41 | ||
42 | int ret = pthread_create (threadp, &attr, tf, arg); | |
43 | ||
44 | (void) pthread_attr_destroy (&attr); | |
45 | return ret; | |
46 | } | |
47 | #endif | |
48 | ||
49 | ||
2ace5721 UD |
50 | /* Pool of request list entries. */ |
51 | static struct requestlist **pool; | |
52 | ||
53 | /* Number of total and allocated pool entries. */ | |
54 | static size_t pool_max_size; | |
55 | static size_t pool_size; | |
56 | ||
57 | /* We implement a two dimensional array but allocate each row separately. | |
58 | The macro below determines how many entries should be used per row. | |
59 | It should better be a power of two. */ | |
60 | #define ENTRIES_PER_ROW 32 | |
61 | ||
62 | /* How many rows we allocate at once. */ | |
63 | #define ROWS_STEP 8 | |
64 | ||
65 | /* List of available entries. */ | |
66 | static struct requestlist *freelist; | |
67 | ||
68 | /* Structure list of all currently processed requests. */ | |
69 | static struct requestlist *requests; | |
70 | static struct requestlist *requests_tail; | |
71 | ||
72 | /* Number of threads currently running. */ | |
73 | static int nthreads; | |
74 | ||
75 | /* Number of threads waiting for work to arrive. */ | |
76 | static int idle_thread_count; | |
77 | ||
78 | ||
79 | /* These are the values used for optimization. We will probably | |
80 | create a funcion to set these values. */ | |
81 | static struct gaiinit optim = | |
82 | { | |
83 | 20, /* int gai_threads; Maximal number of threads. */ | |
84 | 64, /* int gai_num; Number of expected simultanious requests. */ | |
85 | 0, | |
86 | 0, | |
87 | 0, | |
88 | 0, | |
89 | 1, | |
90 | 0 | |
91 | }; | |
92 | ||
93 | ||
94 | /* Since the list is global we need a mutex protecting it. */ | |
95 | pthread_mutex_t __gai_requests_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; | |
96 | ||
97 | /* When you add a request to the list and there are idle threads present, | |
98 | you signal this condition variable. When a thread finishes work, it waits | |
99 | on this condition variable for a time before it actually exits. */ | |
100 | pthread_cond_t __gai_new_request_notification = PTHREAD_COND_INITIALIZER; | |
101 | ||
102 | ||
103 | /* Functions to handle request list pool. */ | |
104 | static struct requestlist * | |
105 | get_elem (void) | |
106 | { | |
107 | struct requestlist *result; | |
108 | ||
109 | if (freelist == NULL) | |
110 | { | |
111 | struct requestlist *new_row; | |
112 | int cnt; | |
113 | ||
114 | if (pool_size + 1 >= pool_max_size) | |
115 | { | |
116 | size_t new_max_size = pool_max_size + ROWS_STEP; | |
117 | struct requestlist **new_tab; | |
118 | ||
119 | new_tab = (struct requestlist **) | |
120 | realloc (pool, new_max_size * sizeof (struct requestlist *)); | |
121 | ||
122 | if (new_tab == NULL) | |
123 | return NULL; | |
124 | ||
125 | pool_max_size = new_max_size; | |
126 | pool = new_tab; | |
127 | } | |
128 | ||
129 | /* Allocate the new row. */ | |
130 | cnt = pool_size == 0 ? optim.gai_num : ENTRIES_PER_ROW; | |
131 | new_row = (struct requestlist *) calloc (cnt, | |
132 | sizeof (struct requestlist)); | |
133 | if (new_row == NULL) | |
134 | return NULL; | |
135 | ||
136 | pool[pool_size++] = new_row; | |
137 | ||
138 | /* Put all the new entries in the freelist. */ | |
139 | do | |
140 | { | |
141 | new_row->next = freelist; | |
142 | freelist = new_row++; | |
143 | } | |
144 | while (--cnt > 0); | |
145 | } | |
146 | ||
147 | result = freelist; | |
148 | freelist = freelist->next; | |
149 | ||
150 | return result; | |
151 | } | |
152 | ||
153 | ||
154 | struct requestlist * | |
2ace5721 UD |
155 | __gai_find_request (const struct gaicb *gaicbp) |
156 | { | |
157 | struct requestlist *runp; | |
158 | ||
159 | runp = requests; | |
160 | while (runp != NULL) | |
161 | if (runp->gaicbp == gaicbp) | |
162 | return runp; | |
163 | else | |
164 | runp = runp->next; | |
165 | ||
166 | return NULL; | |
167 | } | |
168 | ||
169 | ||
170 | int | |
2ace5721 UD |
171 | __gai_remove_request (struct gaicb *gaicbp) |
172 | { | |
173 | struct requestlist *runp; | |
174 | struct requestlist *lastp; | |
175 | ||
176 | runp = requests; | |
177 | lastp = NULL; | |
178 | while (runp != NULL) | |
179 | if (runp->gaicbp == gaicbp) | |
180 | break; | |
181 | else | |
182 | { | |
183 | lastp = runp; | |
184 | runp = runp->next; | |
185 | } | |
186 | ||
187 | if (runp == NULL) | |
188 | /* Not known. */ | |
189 | return -1; | |
190 | if (runp->running != 0) | |
191 | /* Currently handled. */ | |
192 | return 1; | |
193 | ||
194 | /* Dequeue the request. */ | |
195 | if (lastp == NULL) | |
196 | requests = runp->next; | |
197 | else | |
198 | lastp->next = runp->next; | |
199 | if (runp == requests_tail) | |
200 | requests_tail = lastp; | |
201 | ||
202 | return 0; | |
203 | } | |
204 | ||
205 | ||
206 | /* The thread handler. */ | |
207 | static void *handle_requests (void *arg); | |
208 | ||
209 | ||
210 | /* The main function of the async I/O handling. It enqueues requests | |
211 | and if necessary starts and handles threads. */ | |
212 | struct requestlist * | |
2ace5721 UD |
213 | __gai_enqueue_request (struct gaicb *gaicbp) |
214 | { | |
215 | struct requestlist *newp; | |
216 | struct requestlist *lastp; | |
217 | ||
218 | /* Get the mutex. */ | |
219 | pthread_mutex_lock (&__gai_requests_mutex); | |
220 | ||
221 | /* Get a new element for the waiting list. */ | |
222 | newp = get_elem (); | |
223 | if (newp == NULL) | |
224 | { | |
225 | pthread_mutex_unlock (&__gai_requests_mutex); | |
226 | __set_errno (EAGAIN); | |
227 | return NULL; | |
228 | } | |
229 | newp->running = 0; | |
230 | newp->gaicbp = gaicbp; | |
231 | newp->waiting = NULL; | |
232 | newp->next = NULL; | |
233 | ||
234 | lastp = requests_tail; | |
235 | if (requests_tail == NULL) | |
236 | requests = requests_tail = newp; | |
237 | else | |
238 | { | |
239 | requests_tail->next = newp; | |
240 | requests_tail = newp; | |
241 | } | |
242 | ||
243 | gaicbp->__return = EAI_INPROGRESS; | |
244 | ||
245 | /* See if we need to and are able to create a thread. */ | |
246 | if (nthreads < optim.gai_threads && idle_thread_count == 0) | |
247 | { | |
248 | pthread_t thid; | |
2ace5721 UD |
249 | |
250 | newp->running = 1; | |
251 | ||
2ace5721 | 252 | /* Now try to start a thread. */ |
f1762c0c | 253 | if (gai_create_helper_thread (&thid, handle_requests, newp) == 0) |
2ace5721 UD |
254 | /* We managed to enqueue the request. All errors which can |
255 | happen now can be recognized by calls to `gai_error'. */ | |
256 | ++nthreads; | |
257 | else | |
258 | { | |
259 | if (nthreads == 0) | |
260 | { | |
261 | /* We cannot create a thread in the moment and there is | |
262 | also no thread running. This is a problem. `errno' is | |
263 | set to EAGAIN if this is only a temporary problem. */ | |
bd3b0fba AS |
264 | assert (requests == newp || lastp->next == newp); |
265 | if (lastp != NULL) | |
266 | lastp->next = NULL; | |
267 | else | |
268 | requests = NULL; | |
2ace5721 UD |
269 | requests_tail = lastp; |
270 | ||
271 | newp->next = freelist; | |
272 | freelist = newp; | |
273 | ||
274 | newp = NULL; | |
275 | } | |
276 | else | |
277 | /* We are not handling the request after all. */ | |
278 | newp->running = 0; | |
279 | } | |
280 | } | |
281 | ||
282 | /* Enqueue the request in the request queue. */ | |
283 | if (newp != NULL) | |
284 | { | |
285 | /* If there is a thread waiting for work, then let it know that we | |
286 | have just given it something to do. */ | |
287 | if (idle_thread_count > 0) | |
288 | pthread_cond_signal (&__gai_new_request_notification); | |
289 | } | |
290 | ||
291 | /* Release the mutex. */ | |
292 | pthread_mutex_unlock (&__gai_requests_mutex); | |
293 | ||
294 | return newp; | |
295 | } | |
296 | ||
297 | ||
298 | static void * | |
159a2e1a | 299 | __attribute__ ((noreturn)) |
2ace5721 UD |
300 | handle_requests (void *arg) |
301 | { | |
302 | struct requestlist *runp = (struct requestlist *) arg; | |
303 | ||
304 | do | |
305 | { | |
306 | /* If runp is NULL, then we were created to service the work queue | |
307 | in general, not to handle any particular request. In that case we | |
308 | skip the "do work" stuff on the first pass, and go directly to the | |
309 | "get work off the work queue" part of this loop, which is near the | |
310 | end. */ | |
311 | if (runp == NULL) | |
312 | pthread_mutex_lock (&__gai_requests_mutex); | |
313 | else | |
314 | { | |
315 | /* Make the request. */ | |
316 | struct gaicb *req = runp->gaicbp; | |
317 | struct requestlist *srchp; | |
318 | struct requestlist *lastp; | |
319 | ||
320 | req->__return = getaddrinfo (req->ar_name, req->ar_service, | |
321 | req->ar_request, &req->ar_result); | |
322 | ||
323 | /* Get the mutex. */ | |
324 | pthread_mutex_lock (&__gai_requests_mutex); | |
325 | ||
326 | /* Send the signal to notify about finished processing of the | |
327 | request. */ | |
328 | __gai_notify (runp); | |
329 | ||
330 | /* Now dequeue the current request. */ | |
331 | lastp = NULL; | |
332 | srchp = requests; | |
333 | while (srchp != runp) | |
334 | { | |
335 | lastp = srchp; | |
336 | srchp = srchp->next; | |
337 | } | |
338 | assert (runp->running == 1); | |
339 | ||
340 | if (requests_tail == runp) | |
341 | requests_tail = lastp; | |
342 | if (lastp == NULL) | |
343 | requests = requests->next; | |
344 | else | |
345 | lastp->next = runp->next; | |
346 | ||
347 | /* Free the old element. */ | |
348 | runp->next = freelist; | |
349 | freelist = runp; | |
350 | } | |
351 | ||
352 | runp = requests; | |
353 | while (runp != NULL && runp->running != 0) | |
354 | runp = runp->next; | |
355 | ||
356 | /* If the runlist is empty, then we sleep for a while, waiting for | |
357 | something to arrive in it. */ | |
358 | if (runp == NULL && optim.gai_idle_time >= 0) | |
359 | { | |
360 | struct timeval now; | |
361 | struct timespec wakeup_time; | |
362 | ||
363 | ++idle_thread_count; | |
364 | gettimeofday (&now, NULL); | |
365 | wakeup_time.tv_sec = now.tv_sec + optim.gai_idle_time; | |
366 | wakeup_time.tv_nsec = now.tv_usec * 1000; | |
82d86f28 | 367 | if (wakeup_time.tv_nsec >= 1000000000) |
2ace5721 UD |
368 | { |
369 | wakeup_time.tv_nsec -= 1000000000; | |
370 | ++wakeup_time.tv_sec; | |
371 | } | |
372 | pthread_cond_timedwait (&__gai_new_request_notification, | |
373 | &__gai_requests_mutex, &wakeup_time); | |
374 | --idle_thread_count; | |
375 | runp = requests; | |
376 | while (runp != NULL && runp->running != 0) | |
377 | runp = runp->next; | |
378 | } | |
379 | ||
380 | if (runp == NULL) | |
381 | --nthreads; | |
382 | else | |
383 | { | |
384 | /* Mark the request as being worked on. */ | |
385 | assert (runp->running == 0); | |
386 | runp->running = 1; | |
387 | ||
388 | /* If we have a request to process, and there's still another in | |
389 | the run list, then we need to either wake up or create a new | |
390 | thread to service the request that is still in the run list. */ | |
391 | if (requests != NULL) | |
392 | { | |
393 | /* There are at least two items in the work queue to work on. | |
394 | If there are other idle threads, then we should wake them | |
395 | up for these other work elements; otherwise, we should try | |
396 | to create a new thread. */ | |
397 | if (idle_thread_count > 0) | |
398 | pthread_cond_signal (&__gai_new_request_notification); | |
399 | else if (nthreads < optim.gai_threads) | |
400 | { | |
401 | pthread_t thid; | |
402 | pthread_attr_t attr; | |
403 | ||
404 | /* Make sure the thread is created detached. */ | |
405 | pthread_attr_init (&attr); | |
406 | pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED); | |
407 | ||
408 | /* Now try to start a thread. If we fail, no big deal, | |
409 | because we know that there is at least one thread (us) | |
410 | that is working on lookup operations. */ | |
411 | if (pthread_create (&thid, &attr, handle_requests, NULL) | |
412 | == 0) | |
413 | ++nthreads; | |
414 | } | |
415 | } | |
416 | } | |
417 | ||
418 | /* Release the mutex. */ | |
419 | pthread_mutex_unlock (&__gai_requests_mutex); | |
420 | } | |
421 | while (runp != NULL); | |
422 | ||
423 | pthread_exit (NULL); | |
424 | } | |
425 | ||
426 | ||
427 | /* Free allocated resources. */ | |
c877418f | 428 | libc_freeres_fn (free_res) |
2ace5721 UD |
429 | { |
430 | size_t row; | |
431 | ||
432 | for (row = 0; row < pool_max_size; ++row) | |
433 | free (pool[row]); | |
434 | ||
435 | free (pool); | |
436 | } |