1 | /* Copyright (C) 2001-2016 Free Software Foundation, Inc. |
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 |
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. |
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 |
13 | Lesser General Public License for more details. |
14 | |
15 | You should have received a copy of the GNU Lesser General Public |
16 | License along with the GNU C Library; if not, see |
17 | <http://www.gnu.org/licenses/>. */ |
18 | |
19 | #include <assert.h> |
20 | #include <errno.h> |
21 | #include <pthread.h> |
22 | #include <stdlib.h> |
23 | #include <sys/time.h> |
24 | |
25 | #include <gai_misc.h> |
26 | |
27 | |
28 | |
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 | |
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 * |
155 | internal_function |
156 | __gai_find_request (const struct gaicb *gaicbp) |
157 | { |
158 | struct requestlist *runp; |
159 | |
160 | runp = requests; |
161 | while (runp != NULL) |
162 | if (runp->gaicbp == gaicbp) |
163 | return runp; |
164 | else |
165 | runp = runp->next; |
166 | |
167 | return NULL; |
168 | } |
169 | |
170 | |
171 | int |
172 | internal_function |
173 | __gai_remove_request (struct gaicb *gaicbp) |
174 | { |
175 | struct requestlist *runp; |
176 | struct requestlist *lastp; |
177 | |
178 | runp = requests; |
179 | lastp = NULL; |
180 | while (runp != NULL) |
181 | if (runp->gaicbp == gaicbp) |
182 | break; |
183 | else |
184 | { |
185 | lastp = runp; |
186 | runp = runp->next; |
187 | } |
188 | |
189 | if (runp == NULL) |
190 | /* Not known. */ |
191 | return -1; |
192 | if (runp->running != 0) |
193 | /* Currently handled. */ |
194 | return 1; |
195 | |
196 | /* Dequeue the request. */ |
197 | if (lastp == NULL) |
198 | requests = runp->next; |
199 | else |
200 | lastp->next = runp->next; |
201 | if (runp == requests_tail) |
202 | requests_tail = lastp; |
203 | |
204 | return 0; |
205 | } |
206 | |
207 | |
208 | /* The thread handler. */ |
209 | static void *handle_requests (void *arg); |
210 | |
211 | |
212 | /* The main function of the async I/O handling. It enqueues requests |
213 | and if necessary starts and handles threads. */ |
214 | struct requestlist * |
215 | internal_function |
216 | __gai_enqueue_request (struct gaicb *gaicbp) |
217 | { |
218 | struct requestlist *newp; |
219 | struct requestlist *lastp; |
220 | |
221 | /* Get the mutex. */ |
222 | pthread_mutex_lock (&__gai_requests_mutex); |
223 | |
224 | /* Get a new element for the waiting list. */ |
225 | newp = get_elem (); |
226 | if (newp == NULL) |
227 | { |
228 | pthread_mutex_unlock (&__gai_requests_mutex); |
229 | __set_errno (EAGAIN); |
230 | return NULL; |
231 | } |
232 | newp->running = 0; |
233 | newp->gaicbp = gaicbp; |
234 | newp->waiting = NULL; |
235 | newp->next = NULL; |
236 | |
237 | lastp = requests_tail; |
238 | if (requests_tail == NULL) |
239 | requests = requests_tail = newp; |
240 | else |
241 | { |
242 | requests_tail->next = newp; |
243 | requests_tail = newp; |
244 | } |
245 | |
246 | gaicbp->__return = EAI_INPROGRESS; |
247 | |
248 | /* See if we need to and are able to create a thread. */ |
249 | if (nthreads < optim.gai_threads && idle_thread_count == 0) |
250 | { |
251 | pthread_t thid; |
252 | |
253 | newp->running = 1; |
254 | |
255 | /* Now try to start a thread. */ |
256 | if (gai_create_helper_thread (&thid, handle_requests, newp) == 0) |
257 | /* We managed to enqueue the request. All errors which can |
258 | happen now can be recognized by calls to `gai_error'. */ |
259 | ++nthreads; |
260 | else |
261 | { |
262 | if (nthreads == 0) |
263 | { |
264 | /* We cannot create a thread in the moment and there is |
265 | also no thread running. This is a problem. `errno' is |
266 | set to EAGAIN if this is only a temporary problem. */ |
267 | assert (lastp->next == newp); |
268 | lastp->next = NULL; |
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 * |
299 | __attribute__ ((noreturn)) |
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; |
367 | if (wakeup_time.tv_nsec >= 1000000000) |
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. */ |
428 | libc_freeres_fn (free_res) |
429 | { |
430 | size_t row; |
431 | |
432 | for (row = 0; row < pool_max_size; ++row) |
433 | free (pool[row]); |
434 | |
435 | free (pool); |
436 | } |
437 | |