resolv/gai_misc.c

   1 /* Copyright (C) 2001-2020 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    <https://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 __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
 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 *
 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;
 249
 250       newp->running = 1;
 251
 252       /* Now try to start a thread.  */
 253       if (gai_create_helper_thread (&thid, handle_requests, newp) == 0)
 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.  */
 264               assert (requests == newp || lastp->next == newp);
 265               if (lastp != NULL)
 266                 lastp->next = NULL;
 267               else
 268                 requests = 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 timespec now;
 361           struct timespec wakeup_time;
 362
 363           ++idle_thread_count;
 364           __clock_gettime (CLOCK_REALTIME, &now);
 365           wakeup_time.tv_sec = now.tv_sec + optim.gai_idle_time;
 366           wakeup_time.tv_nsec = now.tv_nsec;
 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 }