Update.

	* Versions.def: Add libanl definition.
	* shlig-versions: Add entry for libanl.
	* resolv/Makefile (distribute): Add gai_misc.h and ga_test.c.
	(routines): Add gai_sigqueue.
	(extra-libs): Add libanl.
	(libanl-routines): New variable.
	Add rules to build libanl and ga_test.
	* resolv/Versions [libc] (GLIBC_2.2.3): Add __gai_sigqueue.
	[libanl]: New library.
	* resolv/netdb.h: Add definitions for libanl.
	* resolv/getaddrinfo_a.c: New file.
	* resolv/gai_cancel.c: New file.
	* resolv/gai_error.c: New file.
	* resolv/gai_misc.c: New file.
	* resolv/gai_misc.h: New file.
	* resolv/gai_notify.c: New file.
	* resolv/gai_suspend.c: New file.
	* resolv/ga_test.c: New file.
	* sysdeps/generic/gai_sigqueue.c: New file.
	* sysdeps/unix/sysv/linux/gai_sigqueue.c: New file.
	* sysdeps/generic/bits/siginfo.h: Allow __need_sigevent_t being defined
	and provide only that definition.
	* sysdeps/unix/sysv/linux/alpha/bits/siginfo.h: Likewise.
	* sysdeps/unix/sysv/linux/bits/siginfo.h: Likewise.
	* sysdeps/unix/sysv/linux/ia64/bits/siginfo.h: Likewise.
	* sysdeps/unix/sysv/linux/mips/bits/siginfo.h: Likewise.
	* sysdeps/unix/sysv/linux/sparc/bits/siginfo.h: Likewise.
	* sysdeps/unix/sysv/linux/sparc/sparc64/bits/siginfo.h: Likewise.

	* rt/aio_misc.c: Fix typos in comments.
	* rt/lio_listio.c: Pretty printing.  Little optimization in request
	list handling.

	* elf/rtld.c: Remove commented out code.

1 files changed, 423 insertions, 0 deletions

diff --git a/resolv/gai_misc.c b/resolv/gai_misc.c
new file mode 100644
index 0000000..b69a8f6
--- /dev/null
+++ b/resolv/gai_misc.c
@@ -0,0 +1,423 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@redhat.com>, 2001.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include <assert.h>
+#include <errno.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <sys/time.h>
+
+#include "gai_misc.h"
+
+
+
+/* Pool of request list entries.  */
+static struct requestlist **pool;
+
+/* Number of total and allocated pool entries.  */
+static size_t pool_max_size;
+static size_t pool_size;
+
+/* We implement a two dimensional array but allocate each row separately.
+   The macro below determines how many entries should be used per row.
+   It should better be a power of two.  */
+#define ENTRIES_PER_ROW	32
+
+/* How many rows we allocate at once.  */
+#define ROWS_STEP	8
+
+/* List of available entries.  */
+static struct requestlist *freelist;
+
+/* Structure list of all currently processed requests.  */
+static struct requestlist *requests;
+static struct requestlist *requests_tail;
+
+/* Number of threads currently running.  */
+static int nthreads;
+
+/* Number of threads waiting for work to arrive. */
+static int idle_thread_count;
+
+
+/* These are the values used for optimization.  We will probably
+   create a funcion to set these values.  */
+static struct gaiinit optim =
+{
+  20,	/* int gai_threads;	Maximal number of threads.  */
+  64,	/* int gai_num;		Number of expected simultanious requests. */
+  0,
+  0,
+  0,
+  0,
+  1,
+  0
+};
+
+
+/* Since the list is global we need a mutex protecting it.  */
+pthread_mutex_t __gai_requests_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
+
+/* When you add a request to the list and there are idle threads present,
+   you signal this condition variable. When a thread finishes work, it waits
+   on this condition variable for a time before it actually exits. */
+pthread_cond_t __gai_new_request_notification = PTHREAD_COND_INITIALIZER;
+
+
+/* Functions to handle request list pool.  */
+static struct requestlist *
+get_elem (void)
+{
+  struct requestlist *result;
+
+  if (freelist == NULL)
+    {
+      struct requestlist *new_row;
+      int cnt;
+
+      if (pool_size + 1 >= pool_max_size)
+	{
+	  size_t new_max_size = pool_max_size + ROWS_STEP;
+	  struct requestlist **new_tab;
+
+	  new_tab = (struct requestlist **)
+	    realloc (pool, new_max_size * sizeof (struct requestlist *));
+
+	  if (new_tab == NULL)
+	    return NULL;
+
+	  pool_max_size = new_max_size;
+	  pool = new_tab;
+	}
+
+      /* Allocate the new row.  */
+      cnt = pool_size == 0 ? optim.gai_num : ENTRIES_PER_ROW;
+      new_row = (struct requestlist *) calloc (cnt,
+					       sizeof (struct requestlist));
+      if (new_row == NULL)
+	return NULL;
+
+      pool[pool_size++] = new_row;
+
+      /* Put all the new entries in the freelist.  */
+      do
+	{
+	  new_row->next = freelist;
+	  freelist = new_row++;
+	}
+      while (--cnt > 0);
+    }
+
+  result = freelist;
+  freelist = freelist->next;
+
+  return result;
+}
+
+
+struct requestlist *
+internal_function
+__gai_find_request (const struct gaicb *gaicbp)
+{
+  struct requestlist *runp;
+
+  runp = requests;
+  while (runp != NULL)
+    if (runp->gaicbp == gaicbp)
+      return runp;
+    else
+      runp = runp->next;
+
+  return NULL;
+}
+
+
+int
+internal_function
+__gai_remove_request (struct gaicb *gaicbp)
+{
+  struct requestlist *runp;
+  struct requestlist *lastp;
+
+  runp = requests;
+  lastp = NULL;
+  while (runp != NULL)
+    if (runp->gaicbp == gaicbp)
+      break;
+    else
+      {
+	lastp = runp;
+	runp = runp->next;
+      }
+
+  if (runp == NULL)
+    /* Not known.  */
+    return -1;
+  if (runp->running != 0)
+    /* Currently handled.  */
+    return 1;
+
+  /* Dequeue the request.  */
+  if (lastp == NULL)
+    requests = runp->next;
+  else
+    lastp->next = runp->next;
+  if (runp == requests_tail)
+    requests_tail = lastp;
+
+  return 0;
+}
+
+
+/* The thread handler.  */
+static void *handle_requests (void *arg);
+
+
+/* The main function of the async I/O handling.  It enqueues requests
+   and if necessary starts and handles threads.  */
+struct requestlist *
+internal_function
+__gai_enqueue_request (struct gaicb *gaicbp)
+{
+  struct requestlist *newp;
+  struct requestlist *lastp;
+
+  /* Get the mutex.  */
+  pthread_mutex_lock (&__gai_requests_mutex);
+
+  /* Get a new element for the waiting list.  */
+  newp = get_elem ();
+  if (newp == NULL)
+    {
+      pthread_mutex_unlock (&__gai_requests_mutex);
+      __set_errno (EAGAIN);
+      return NULL;
+    }
+  newp->running = 0;
+  newp->gaicbp = gaicbp;
+  newp->waiting = NULL;
+  newp->next = NULL;
+
+  lastp = requests_tail;
+  if (requests_tail == NULL)
+    requests = requests_tail = newp;
+  else
+    {
+      requests_tail->next = newp;
+      requests_tail = newp;
+    }
+
+  gaicbp->__return = EAI_INPROGRESS;
+
+  /* See if we need to and are able to create a thread.  */
+  if (nthreads < optim.gai_threads && idle_thread_count == 0)
+    {
+      pthread_t thid;
+      pthread_attr_t attr;
+
+      newp->running = 1;
+
+      /* Make sure the thread is created detached.  */
+      pthread_attr_init (&attr);
+      pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+
+      /* Now try to start a thread.  */
+      if (pthread_create (&thid, &attr, handle_requests, newp) == 0)
+	/* We managed to enqueue the request.  All errors which can
+	   happen now can be recognized by calls to `gai_error'.  */
+	++nthreads;
+      else
+	{
+	  if (nthreads == 0)
+	    {
+	      /* We cannot create a thread in the moment and there is
+		 also no thread running.  This is a problem.  `errno' is
+		 set to EAGAIN if this is only a temporary problem.  */
+	      assert (lastp->next == newp);
+	      lastp->next = NULL;
+	      requests_tail = lastp;
+
+	      newp->next = freelist;
+	      freelist = newp;
+
+	      newp = NULL;
+	    }
+	  else
+	    /* We are not handling the request after all.  */
+	    newp->running = 0;
+	}
+    }
+
+  /* Enqueue the request in the request queue.  */
+  if (newp != NULL)
+    {
+      /* If there is a thread waiting for work, then let it know that we
+	 have just given it something to do. */
+      if (idle_thread_count > 0)
+	pthread_cond_signal (&__gai_new_request_notification);
+    }
+
+  /* Release the mutex.  */
+  pthread_mutex_unlock (&__gai_requests_mutex);
+
+  return newp;
+}
+
+
+static void *
+handle_requests (void *arg)
+{
+  struct requestlist *runp = (struct requestlist *) arg;
+
+  do
+    {
+      /* If runp is NULL, then we were created to service the work queue
+	 in general, not to handle any particular request. In that case we
+	 skip the "do work" stuff on the first pass, and go directly to the
+	 "get work off the work queue" part of this loop, which is near the
+	 end. */
+      if (runp == NULL)
+	pthread_mutex_lock (&__gai_requests_mutex);
+      else
+	{
+	  /* Make the request.  */
+	  struct gaicb *req = runp->gaicbp;
+	  struct requestlist *srchp;
+	  struct requestlist *lastp;
+
+	  req->__return = getaddrinfo (req->ar_name, req->ar_service,
+				       req->ar_request, &req->ar_result);
+
+	  /* Get the mutex.  */
+	  pthread_mutex_lock (&__gai_requests_mutex);
+
+	  /* Send the signal to notify about finished processing of the
+	     request.  */
+	  __gai_notify (runp);
+
+	  /* Now dequeue the current request.  */
+	  lastp = NULL;
+	  srchp = requests;
+	  while (srchp != runp)
+	    {
+	      lastp = srchp;
+	      srchp = srchp->next;
+	    }
+	  assert (runp->running == 1);
+
+	  if (requests_tail == runp)
+	    requests_tail = lastp;
+	  if (lastp == NULL)
+	    requests = requests->next;
+	  else
+	    lastp->next = runp->next;
+
+	  /* Free the old element.  */
+	  runp->next = freelist;
+	  freelist = runp;
+	}
+
+      runp = requests;
+      while (runp != NULL && runp->running != 0)
+	runp = runp->next;
+
+      /* If the runlist is empty, then we sleep for a while, waiting for
+	 something to arrive in it. */
+      if (runp == NULL && optim.gai_idle_time >= 0)
+	{
+	  struct timeval now;
+	  struct timespec wakeup_time;
+
+	  ++idle_thread_count;
+	  gettimeofday (&now, NULL);
+	  wakeup_time.tv_sec = now.tv_sec + optim.gai_idle_time;
+	  wakeup_time.tv_nsec = now.tv_usec * 1000;
+	  if (wakeup_time.tv_nsec > 1000000000)
+	    {
+	      wakeup_time.tv_nsec -= 1000000000;
+	      ++wakeup_time.tv_sec;
+	    }
+	  pthread_cond_timedwait (&__gai_new_request_notification,
+				  &__gai_requests_mutex, &wakeup_time);
+	  --idle_thread_count;
+	  runp = requests;
+	  while (runp != NULL && runp->running != 0)
+	    runp = runp->next;
+	}
+
+      if (runp == NULL)
+	--nthreads;
+      else
+	{
+	  /* Mark the request as being worked on.  */
+	  assert (runp->running == 0);
+	  runp->running = 1;
+
+	  /* If we have a request to process, and there's still another in
+	     the run list, then we need to either wake up or create a new
+	     thread to service the request that is still in the run list. */
+	  if (requests != NULL)
+	    {
+	      /* There are at least two items in the work queue to work on.
+		 If there are other idle threads, then we should wake them
+		 up for these other work elements; otherwise, we should try
+		 to create a new thread. */
+	      if (idle_thread_count > 0)
+		pthread_cond_signal (&__gai_new_request_notification);
+	      else if (nthreads < optim.gai_threads)
+		{
+		  pthread_t thid;
+		  pthread_attr_t attr;
+
+		  /* Make sure the thread is created detached.  */
+		  pthread_attr_init (&attr);
+		  pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+
+		  /* Now try to start a thread. If we fail, no big deal,
+		     because we know that there is at least one thread (us)
+		     that is working on lookup operations. */
+		  if (pthread_create (&thid, &attr, handle_requests, NULL)
+		      == 0)
+		    ++nthreads;
+		}
+	    }
+	}
+
+      /* Release the mutex.  */
+      pthread_mutex_unlock (&__gai_requests_mutex);
+    }
+  while (runp != NULL);
+
+  pthread_exit (NULL);
+}
+
+
+/* Free allocated resources.  */
+static void
+__attribute__ ((unused))
+free_res (void)
+{
+  size_t row;
+
+  for (row = 0; row < pool_max_size; ++row)
+    free (pool[row]);
+
+  free (pool);
+}
+text_set_element (__libc_subfreeres, free_res);