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