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 }