drop patch series

3 files changed, 0 insertions, 889 deletions

diff --git a/libhurd-slab/Makefile b/libhurd-slab/Makefile
deleted file mode 100644
index 925f70c1..00000000
--- a/libhurd-slab/Makefile
+++ /dev/null
@@ -1,33 +0,0 @@
-#
-#   Copyright (C) 1994,95,96,97,98,99,2000,01,02,2005 Free Software Foundation, Inc.
-#
-#   This program is free software; you can redistribute it and/or
-#   modify it under the terms of the GNU General Public License as
-#   published by the Free Software Foundation; either version 2, or (at
-#   your option) any later version.
-#
-#   This program 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
-#   General Public License for more details.
-#
-#   You should have received a copy of the GNU General Public License
-#   along with this program; if not, write to the Free Software
-#   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-dir := libhurd-slab
-makemode := library
-
-libname = libhurd-slab
-SRCS= slab.c
-LCLHDRS = slab.h
-installhdrs = slab.h
-
-MIGSTUBS = 
-OBJS = $(sort $(SRCS:.c=.o) $(MIGSTUBS))
-
-OTHERLIBS = -lpthread
-
-MIGCOMSFLAGS =
-
-include ../Makeconf
diff --git a/libhurd-slab/slab.c b/libhurd-slab/slab.c
deleted file mode 100644
index 5a12a43a..00000000
--- a/libhurd-slab/slab.c
+++ /dev/null
@@ -1,518 +0,0 @@
-/* Copyright (C) 2003, 2005 Free Software Foundation, Inc.
-   Written by Johan Rydberg.
-
-   This file is part of the GNU Hurd.
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This program 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
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this program; if not, write to the Free
-   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-   02111-1307 USA.  */
-
-#if HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <stdlib.h>
-#include <errno.h>
-#include <sys/mman.h>
-#include <assert.h>
-#include <string.h>
-#include <unistd.h>
-#include <pthread.h>
-#include <stdint.h>
-
-#include "slab.h"
-
-#define SLAB_PAGES 4
-
-
-/* Number of pages the slab allocator has allocated.  */
-static int __hurd_slab_nr_pages;
-
-
-/* Buffer control structure.  Lives at the end of an object.  If the
-   buffer is allocated, SLAB points to the slab to which it belongs.
-   If the buffer is free, NEXT points to next buffer on free list.  */
-union hurd_bufctl
-{
-  union hurd_bufctl *next;
-  struct hurd_slab *slab;
-};
-
-
-/* When the allocator needs to grow a cache, it allocates a slab.  A
-   slab consists of one or more pages of memory, split up into equally
-   sized chunks.  */
-struct hurd_slab
-{
-  struct hurd_slab *next;
-  struct hurd_slab *prev;
-
-  /* The reference counter holds the number of allocated chunks in
-     the slab.  When the counter is zero, all chunks are free and
-     the slab can be relinquished.  */
-  int refcount;
-
-  /* Single linked list of free buffers in the slab.  */
-  union hurd_bufctl *free_list;
-};
-
-/* Allocate a buffer in *PTR of size SIZE which must be a power of 2
-   and self aligned (i.e. aligned on a SIZE byte boundary) for slab
-   space SPACE.  Return 0 on success, an error code on failure.  */
-static error_t
-allocate_buffer (struct hurd_slab_space *space, size_t size, void **ptr)
-{
-  if (space->allocate_buffer)
-    return space->allocate_buffer (space->hook, size, ptr);
-  else
-    {
-      *ptr = mmap (NULL, size, PROT_READ|PROT_WRITE,
-		   MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
-      if (*ptr == MAP_FAILED)
-	return errno;
-      else
-	return 0;
-    }
-}
-
-/* Deallocate buffer BUFFER of size SIZE which was allocated for slab
-   space SPACE.  Return 0 on success, an error code on failure.  */
-static error_t
-deallocate_buffer (struct hurd_slab_space *space, void *buffer, size_t size)
-{
-  if (space->deallocate_buffer)
-    return space->deallocate_buffer (space->hook, buffer, size);
-  else
-    {
-      if (munmap (buffer, size) == -1)
-	return errno;
-      else
-	return 0;
-    }
-}
-
-/* Insert SLAB into the list of slabs in SPACE.  SLAB is expected to
-   be complete (so it will be inserted at the end).  */
-static void
-insert_slab (struct hurd_slab_space *space, struct hurd_slab *slab)
-{
-  assert (slab->refcount == 0);
-  if (space->slab_first == 0)
-    space->slab_first = space->slab_last = slab;
-  else
-    {
-      space->slab_last->next = slab;
-      slab->prev = space->slab_last;
-      space->slab_last = slab;
-    }
-}
-
-
-/* Remove SLAB from list of slabs in SPACE.  */
-static void
-remove_slab (struct hurd_slab_space *space, struct hurd_slab *slab)
-{
-  if (slab != space->slab_first
-      && slab != space->slab_last)
-    {
-      slab->next->prev = slab->prev;
-      slab->prev->next = slab->next;
-      return;
-    }
-  if (slab == space->slab_first)
-    {
-      space->slab_first = slab->next;
-      if (space->slab_first)
-	space->slab_first->prev = NULL;
-    }
-  if (slab == space->slab_last)
-    {
-      if (slab->prev)
-	slab->prev->next = NULL;
-      space->slab_last = slab->prev;
-    }
-}
-
-
-/* Iterate through slabs in SPACE and release memory for slabs that
-   are complete (no allocated buffers).  */
-static error_t
-reap (struct hurd_slab_space *space)
-{
-  struct hurd_slab *s, *next, *new_first;
-  error_t err = 0;
-
-  for (s = space->slab_first; s; s = next)
-    {
-      next = s->next;
-
-      /* If the reference counter is zero there is no allocated
-	 buffers, so it can be freed.  */
-      if (!s->refcount)
-	{
-	  remove_slab (space, s);
-	  
-	  /* If there is a destructor it must be invoked for every 
-	     buffer in the slab.  */
-	  if (space->destructor)
-	    {
-	      union hurd_bufctl *bufctl;
-	      for (bufctl = s->free_list; bufctl; bufctl = bufctl->next)
-		{
-		  void *buffer = (((void *) bufctl) 
-				  - (space->size - sizeof *bufctl));
-		  (*space->destructor) (space->hook, buffer);
-		}
-	    }
-	  /* The slab is located at the end of the page (with the buffers
-	     in front of it), get address by masking with page size.  
-	     This frees the slab and all its buffers, since they live on
-	     the same page.  */
-	  err = deallocate_buffer (space, (void *) (((uintptr_t) s)
-						    + sizeof (struct hurd_slab)
-						    - space->slab_size), 
-				   space->slab_size);
-	  if (err)
-	    break;
-	  __hurd_slab_nr_pages--;
-	}
-    }
-
-  /* Even in the case of an error, first_free must be updated since
-     that slab may have been deallocated.  */
-  new_first = space->slab_first;
-  while (new_first)
-    {
-      if (new_first->refcount != space->full_refcount)
-	break;
-      new_first = new_first->next;
-    }
-  space->first_free = new_first;
-
-  return err;
-}
-
-
-/* Initialize slab space SPACE.  */
-static void
-init_space (hurd_slab_space_t space)
-{
-  size_t size = space->requested_size + sizeof (union hurd_bufctl);
-  size_t alignment = space->requested_align;
-
-  /* If SIZE is so big that one object can not fit into a page
-     something gotta be really wrong.  */ 
-  size = (size + alignment - 1) & ~(alignment - 1);
-  assert (size <= (space->slab_size 
-		   - sizeof (struct hurd_slab) 
-		   - sizeof (union hurd_bufctl)));
-
-  space->size = size;
-
-  /* Number of objects that fit into one page.  Used to detect when
-     there are no free objects left in a slab.  */
-  space->full_refcount 
-    = ((space->slab_size - sizeof (struct hurd_slab)) / size);
-
-  /* FIXME: Notify pager's reap functionality about this slab
-     space.  */
-
-  space->initialized = true;
-}
-
-
-/* SPACE has no more memory.  Allocate new slab and insert it into the
-   list, repoint free_list and return possible error.  */
-static error_t
-grow (struct hurd_slab_space *space)
-{
-  error_t err;
-  struct hurd_slab *new_slab;
-  union hurd_bufctl *bufctl;
-  int nr_objs, i;
-  void *p;
-
-  /* If the space has not yet been initialized this is the place to do
-     so.  It is okay to test some fields such as first_free prior to
-     initialization since they will be a null pointer in any case.  */
-  if (!space->initialized)
-    init_space (space);
-
-  err = allocate_buffer (space, space->slab_size, &p);
-  if (err)
-    return err;
-
-  __hurd_slab_nr_pages++;
-
-  new_slab = (p + space->slab_size - sizeof (struct hurd_slab));
-  memset (new_slab, 0, sizeof (*new_slab));
-
-  /* Calculate the number of objects that the page can hold.
-     SPACE->size should be adjusted to handle alignment.  */
-  nr_objs = ((space->slab_size - sizeof (struct hurd_slab))
-	     / space->size);
-  
-  for (i = 0; i < nr_objs; i++, p += space->size)
-    {
-      /* Invoke constructor at object creation time, not when it is
-	 really allocated (for faster allocation).  */
-      if (space->constructor)
-	{
-	  error_t err = (*space->constructor) (space->hook, p);
-	  if (err)
-	    {
-	      /* The allocated page holds both slab and memory
-		 objects.  Call the destructor for objects that has
-		 been initialized.  */
-	      for (bufctl = new_slab->free_list; bufctl;
-		   bufctl = bufctl->next)
-		{
-		  void *buffer = (((void *) bufctl) 
-				  - (space->size - sizeof *bufctl));
-		  (*space->destructor) (space->hook, buffer);
-		}
-
-	      deallocate_buffer (space, p, space->slab_size);
-	      return err;
-	    }
-	}
-
-      /* The most activity is in front of the object, so it is most
-	 likely to be overwritten if a freed buffer gets accessed.
-	 Therefor, put the bufctl structure at the end of the
-	 object.  */
-      bufctl = (p + space->size - sizeof *bufctl);
-      bufctl->next = new_slab->free_list;
-      new_slab->free_list = bufctl;
-    }
-
-  /* Insert slab into the list of available slabs for this cache.  The
-     only time a slab should be allocated is when there is no more
-     buffers, so it is safe to repoint first_free.  */  
-  insert_slab (space, new_slab);
-  space->first_free = new_slab;
-  return 0;
-}
-
-
-/* Initialize the slab space SPACE.  */
-error_t
-hurd_slab_init (hurd_slab_space_t space, size_t size, size_t alignment,
-		hurd_slab_allocate_buffer_t allocate_buffer,
-		hurd_slab_deallocate_buffer_t deallocate_buffer,
-		hurd_slab_constructor_t constructor,
-		hurd_slab_destructor_t destructor,
-		void *hook)
-{
-  error_t err;
-
-  /* Initialize all members to zero by default.  */
-  memset (space, 0, sizeof (struct hurd_slab_space));
-
-  if (!alignment)
-    /* FIXME: Is this a good default?  Maybe eight (8) is better,
-       since several architectures require that double and friends are
-       eight byte aligned.  */
-    alignment = __alignof__ (void *);
-
-  space->requested_size = size;
-  space->requested_align = alignment;
-  space->slab_size = getpagesize () * SLAB_PAGES;
-
-  /* Testing the size here avoids an assertion in init_space.  */
-  size = size + sizeof (union hurd_bufctl);
-  size = (size + alignment - 1) & ~(alignment - 1);
-  if (size > (space->slab_size - sizeof (struct hurd_slab)
-	      - sizeof (union hurd_bufctl)))
-    return EINVAL;
-
-  err = pthread_mutex_init (&space->lock, NULL);
-  if (err)
-    return err;
-
-  space->allocate_buffer = allocate_buffer;
-  space->deallocate_buffer = deallocate_buffer;
-  space->constructor = constructor;
-  space->destructor = destructor;
-  space->hook = hook;
-
-  /* The remaining fields will be initialized by init_space.  */
-  return 0;
-}
-
-
-/* Create a new slab space with the given object size, alignment,
-   constructor and destructor.  ALIGNMENT can be zero.  */
-error_t
-hurd_slab_create (size_t size, size_t alignment,
-		  hurd_slab_allocate_buffer_t allocate_buffer,
-		  hurd_slab_deallocate_buffer_t deallocate_buffer,
-		  hurd_slab_constructor_t constructor,
-		  hurd_slab_destructor_t destructor,
-		  void *hook,
-		  hurd_slab_space_t *r_space)
-{
-  hurd_slab_space_t space;
-  error_t err;
-
-  space = malloc (sizeof (struct hurd_slab_space));
-  if (!space)
-    return ENOMEM;
-
-  err = hurd_slab_init (space, size, alignment,
-			allocate_buffer, deallocate_buffer,
-			constructor, destructor, hook);
-  if (err)
-    {
-      free (space);
-      return err;
-    }
-
-  *r_space = space;
-  return 0;
-}
-
-
-/* Destroy all objects and the slab space SPACE.  Returns EBUSY if
-   there are still allocated objects in the slab.  */
-error_t
-hurd_slab_destroy (hurd_slab_space_t space)
-{
-  error_t err;
-
-  /* The caller wants to destroy the slab.  It can not be destroyed if
-     there are any outstanding memory allocations.  */
-  pthread_mutex_lock (&space->lock);
-  err = reap (space);
-  if (err)
-    {
-      pthread_mutex_unlock (&space->lock);
-      return err;
-    }
-
-  if (space->slab_first)
-    {
-      /* There are still slabs, i.e. there is outstanding allocations.
-	 Return EBUSY.  */
-      pthread_mutex_unlock (&space->lock);
-      return EBUSY;
-    }
-
-  /* FIXME: Remove slab space from pager's reap functionality.  */
-
-  return 0;
-}
-
-
-/* Destroy all objects and the slab space SPACE.  If there were no
-   outstanding allocations free the slab space.  Returns EBUSY if
-   there are still allocated objects in the slab space.  */
-error_t
-hurd_slab_free (hurd_slab_space_t space)
-{
-  error_t err = hurd_slab_destroy (space);
-  if (err)
-    return err;
-  free (space);
-  return 0;
-}
-
-
-/* Allocate a new object from the slab space SPACE.  */
-error_t
-hurd_slab_alloc (hurd_slab_space_t space, void **buffer)
-{
-  error_t err;
-  union hurd_bufctl *bufctl;
-
-  pthread_mutex_lock (&space->lock);
-
-  /* If there is no slabs with free buffer, the cache has to be
-     expanded with another slab.  If the slab space has not yet been
-     initialized this is always true.  */
-  if (!space->first_free)
-    {
-      err = grow (space);
-      if (err)
-	{
-	  pthread_mutex_unlock (&space->lock);
-	  return err;
-	}
-    }
-
-  /* Remove buffer from the free list and update the reference
-     counter.  If the reference counter will hit the top, it is
-     handled at the time of the next allocation.  */
-  bufctl = space->first_free->free_list;
-  space->first_free->free_list = bufctl->next;
-  space->first_free->refcount++;
-  bufctl->slab = space->first_free;
-
-  /* If the reference counter hits the top it means that there has
-     been an allocation boost, otherwise dealloc would have updated
-     the first_free pointer.  Find a slab with free objects.  */
-  if (space->first_free->refcount == space->full_refcount)
-    {
-      struct hurd_slab *new_first = space->slab_first;
-      while (new_first)
-	{
-	  if (new_first->refcount != space->full_refcount)
-	    break;
-	  new_first = new_first->next;
-	}
-      /* If first_free is set to NULL here it means that there are
-	 only empty slabs.  The next call to alloc will allocate a new
-	 slab if there was no call to dealloc in the meantime.  */
-      space->first_free = new_first;
-    }
-  *buffer = ((void *) bufctl) - (space->size - sizeof *bufctl);
-  pthread_mutex_unlock (&space->lock);
-  return 0;
-}
-
-
-static inline void
-put_on_slab_list (struct hurd_slab *slab, union hurd_bufctl *bufctl)
-{
-  bufctl->next = slab->free_list;
-  slab->free_list = bufctl;
-  slab->refcount--;
-  assert (slab->refcount >= 0);
-}
-
-
-/* Deallocate the object BUFFER from the slab space SPACE.  */
-void
-hurd_slab_dealloc (hurd_slab_space_t space, void *buffer)
-{
-  struct hurd_slab *slab;
-  union hurd_bufctl *bufctl;
-
-  assert (space->initialized);
-
-  pthread_mutex_lock (&space->lock);
-
-  bufctl = (buffer + (space->size - sizeof *bufctl));
-  put_on_slab_list (slab = bufctl->slab, bufctl);
-
-  /* Try to have first_free always pointing at the slab that has the
-     most number of free objects.  So after this deallocation, update
-     the first_free pointer if reference counter drops below the
-     current reference counter of first_free.  */
-  if (!space->first_free 
-      || slab->refcount < space->first_free->refcount)
-    space->first_free = slab;
-
-  pthread_mutex_unlock (&space->lock);
-}
diff --git a/libhurd-slab/slab.h b/libhurd-slab/slab.h
deleted file mode 100644
index 6eeb8e48..00000000
--- a/libhurd-slab/slab.h
+++ /dev/null
@@ -1,338 +0,0 @@
-/* slab.h - The GNU Hurd slab allocator interface.
-   Copyright (C) 2003, 2005 Free Software Foundation, Inc.
-   Written by Marcus Brinkmann <marcus@gnu.org>
-
-   This file is part of the GNU Hurd.
-
-   This program is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   This program 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
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with this program; if not, write to the Free
-   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-   02111-1307 USA.  */
-
-#ifndef _HURD_SLAB_H
-#define _HURD_SLAB_H	1
-
-#include <errno.h>
-#include <stdbool.h>
-#include <pthread.h>
-
-
-/* Allocate a buffer in *PTR of size SIZE which must be a power of 2
-   and self aligned (i.e. aligned on a SIZE byte boundary).  HOOK is
-   as provided to hurd_slab_create.  Return 0 on success, an error
-   code on failure.  */
-typedef error_t (*hurd_slab_allocate_buffer_t) (void *hook, size_t size,
-						void **ptr);
-
-/* Deallocate buffer BUFFER of size SIZE.  HOOK is as provided to
-   hurd_slab_create.  */
-typedef error_t (*hurd_slab_deallocate_buffer_t) (void *hook, void *buffer,
-						  size_t size);
-
-/* Initialize the slab object pointed to by OBJECT.  HOOK is as
-   provided to hurd_slab_create.  */
-typedef error_t (*hurd_slab_constructor_t) (void *hook, void *object);
-
-/* Destroy the slab object pointed to by OBJECT.  HOOK is as provided
-   to hurd_slab_create.  */
-typedef void (*hurd_slab_destructor_t) (void *hook, void *object);
-
-
-/* The type of a slab space.  
-
-   The structure is divided into two parts: the first is only used
-   while the slab space is constructed.  Its fields are either
-   initialized by a static initializer (HURD_SLAB_SPACE_INITIALIZER)
-   or by the hurd_slab_create function.  The initialization of the
-   space is delayed until the first allocation.  After that only the
-   second part is used.  */
-
-typedef struct hurd_slab_space *hurd_slab_space_t;
-struct hurd_slab_space
-{
-  /* First part.  Used when initializing slab space object.   */
-  
-  /* True if slab space has been initialized.  */
-  bool initialized;
-  
-  /* Protects this structure, along with all the slabs.  No need to
-     delay initialization of this field.  */
-  pthread_mutex_t lock;
-
-  /* The size and alignment of objects allocated using this slab
-     space.  These to fields are used to calculate the final object
-     size, which is put in SIZE (defined below).  */
-  size_t requested_size;
-  size_t requested_align;
-
-  /* The size of each slab. */
-  size_t slab_size;
-
-  /* The buffer allocator.  */
-  hurd_slab_allocate_buffer_t allocate_buffer;
-
-  /* The buffer deallocator.  */
-  hurd_slab_deallocate_buffer_t deallocate_buffer;
-
-  /* The constructor.  */
-  hurd_slab_constructor_t constructor;
-
-  /* The destructor.  */
-  hurd_slab_destructor_t destructor;
-
-  /* The user's private data.  */
-  void *hook;
-
-  /* Second part.  Runtime information for the slab space.  */
-
-  struct hurd_slab *slab_first;
-  struct hurd_slab *slab_last;
-
-  /* In the doubly-linked list of slabs, empty slabs come first, after
-     that the slabs that have some buffers allocated, and finally the
-     complete slabs (refcount == 0).  FIRST_FREE points to the first
-     non-empty slab.  */
-  struct hurd_slab *first_free;
-
-  /* For easy checking, this holds the value the reference counter
-     should have for an empty slab.  */
-  int full_refcount;
-
-  /* The size of one object.  Should include possible alignment as
-     well as the size of the bufctl structure.  */
-  size_t size;
-};
-
-
-/* Static initializer.  TYPE is used to get size and alignment of
-   objects the slab space will be used to allocate.  ALLOCATE_BUFFER
-   may be NULL in which case mmap is called.  DEALLOCATE_BUFFER may be
-   NULL in which case munmap is called.  CTOR and DTOR are the slab's
-   object constructor and destructor, respectivly and may be NULL if
-   not required.  HOOK is passed as user data to the constructor and
-   destructor.  */
-#define HURD_SLAB_SPACE_INITIALIZER(TYPE, ALLOC, DEALLOC, CTOR,	\
-				    DTOR, HOOK)			\
-  {								\
-    false,							\
-    PTHREAD_MUTEX_INITIALIZER, 					\
-    sizeof (TYPE),						\
-    __alignof__ (TYPE),						\
-    ALLOC,							\
-    DEALLOC,							\
-    CTOR,							\
-    DTOR,							\
-    HOOK							\
-    /* The rest of the structure will be filled with zeros,     \
-       which is good for us.  */				\
-  }
-
-
-/* Create a new slab space with the given object size, alignment,
-   constructor and destructor.  ALIGNMENT can be zero.
-   ALLOCATE_BUFFER may be NULL in which case mmap is called.
-   DEALLOCATE_BUFFER may be NULL in which case munmap is called.  CTOR
-   and DTOR are the slabs object constructor and destructor,
-   respectivly and may be NULL if not required.  HOOK is passed as the
-   first argument to the constructor and destructor.  */
-error_t hurd_slab_create (size_t size, size_t alignment,
-			  hurd_slab_allocate_buffer_t allocate_buffer,
-			  hurd_slab_deallocate_buffer_t deallocate_buffer,
-			  hurd_slab_constructor_t constructor,
-			  hurd_slab_destructor_t destructor,
-			  void *hook,
-			  hurd_slab_space_t *space);
-
-/* Destroy all objects and the slab space SPACE.  If there were no
-   outstanding allocations free the slab space.  Returns EBUSY if
-   there are still allocated objects in the slab space.  The dual of
-   hurd_slab_create.  */
-error_t hurd_slab_free (hurd_slab_space_t space);
-
-/* Like hurd_slab_create, but does not allocate storage for the slab.  */
-error_t hurd_slab_init (hurd_slab_space_t space, size_t size, size_t alignment,
-			hurd_slab_allocate_buffer_t allocate_buffer,
-			hurd_slab_deallocate_buffer_t deallocate_buffer,
-			hurd_slab_constructor_t constructor,
-			hurd_slab_destructor_t destructor,
-			void *hook);
-
-/* Destroy all objects and the slab space SPACE.  Returns EBUSY if
-   there are still allocated objects in the slab.  The dual of
-   hurd_slab_init.  */
-error_t hurd_slab_destroy (hurd_slab_space_t space);
-
-/* Allocate a new object from the slab space SPACE.  */
-error_t hurd_slab_alloc (hurd_slab_space_t space, void **buffer);
-
-/* Deallocate the object BUFFER from the slab space SPACE.  */
-void hurd_slab_dealloc (hurd_slab_space_t space, void *buffer);
-
-/* Create a more strongly typed slab interface a la a C++ template.
-
-   NAME is the name of the new slab class.  NAME is used to synthesize
-   names for the class types and methods using the following rule: the
-   hurd_ namespace will prefix all method names followed by NAME
-   followed by an underscore and finally the method name.  The
-   following are thus exposed:
-
-    Types:
-     struct hurd_NAME_slab_space
-     hurd_NAME_slab_space_t
-
-     error_t (*hurd_NAME_slab_constructor_t) (void *hook, element_type *buffer)
-     void (*hurd_NAME_slab_destructor_t) (void *hook, element_type *buffer)
-
-    Functions:
-     error_t hurd_NAME_slab_create (hurd_slab_allocate_buffer_t
-                                     allocate_buffer,
-                                    hurd_slab_deallocate_buffer_t
-                                     deallocate_buffer,
-                                    hurd_NAME_slab_constructor_t constructor,
-                                    hurd_NAME_slab_destructor_t destructor,
-                                    void *hook,
-                                    hurd_NAME_slab_space_t *space);
-     error_t hurd_NAME_slab_free (hurd_NAME_slab_space_t space);
-
-     error_t hurd_NAME_slab_init (hurd_NAME_slab_space_t space,
-                                  hurd_slab_allocate_buffer_t allocate_buffer,
-                                  hurd_slab_deallocate_buffer_t
-                                   deallocate_buffer,
-                                  hurd_NAME_slab_constructor_t constructor,
-                                  hurd_NAME_slab_destructor_t destructor,
-                                  void *hook);
-     error_t hurd_NAME_slab_destroy (hurd_NAME_slab_space_t space);
-
-     error_t hurd_NAME_slab_alloc (hurd_NAME_slab_space_t space,
-                                   element_type **buffer);
-     void hurd_NAME_slab_dealloc (hurd_NAME_slab_space_t space,
-                                  element_type *buffer);
-
-  ELEMENT_TYPE is the type of elements to store in the slab.  If you
-  want the slab to contain struct foo, pass `struct foo' as the
-  ELEMENT_TYPE (not `struct foo *'!!!).
-     
-*/
-#define SLAB_CLASS(name, element_type)                                       \
-struct hurd_##name##_slab_space						     \
-{									     \
-  struct hurd_slab_space space;						     \
-};									     \
-typedef struct hurd_##name##_slab_space *hurd_##name##_slab_space_t;	     \
-									     \
-typedef error_t (*hurd_##name##_slab_constructor_t) (void *hook,	     \
-						     element_type *buffer);  \
-									     \
-typedef void (*hurd_##name##_slab_destructor_t) (void *hook,		     \
-						 element_type *buffer);	     \
-									     \
-static inline error_t							     \
-hurd_##name##_slab_create (hurd_slab_allocate_buffer_t allocate_buffer,	     \
-			   hurd_slab_deallocate_buffer_t deallocate_buffer,  \
-			   hurd_##name##_slab_constructor_t constructor,     \
-			   hurd_##name##_slab_destructor_t destructor,	     \
-			   void *hook,					     \
-			   hurd_##name##_slab_space_t *space)		     \
-{									     \
-  union									     \
-  {									     \
-    hurd_##name##_slab_constructor_t t;					     \
-    hurd_slab_constructor_t u;						     \
-  } con;								     \
-  union									     \
-  {									     \
-    hurd_##name##_slab_destructor_t t;					     \
-    hurd_slab_destructor_t u;						     \
-  } des;								     \
-  union									     \
-  {									     \
-    hurd_##name##_slab_space_t *t;					     \
-    hurd_slab_space_t *u;						     \
-  } foo;								     \
-  con.t = constructor;							     \
-  des.t = destructor;							     \
-  foo.t = space;							     \
-									     \
-  return hurd_slab_create(sizeof (element_type), __alignof__ (element_type), \
-			  allocate_buffer, deallocate_buffer,		     \
-			  con.u, des.u, hook, foo.u);			     \
-}									     \
-									     \
-static inline error_t							     \
-hurd_##name##_slab_free (hurd_##name##_slab_space_t space)		     \
-{									     \
-  return hurd_slab_free (&space->space);				     \
-}									     \
-									     \
-static inline error_t							     \
-hurd_##name##_slab_init (hurd_##name##_slab_space_t space,		     \
-			 hurd_slab_allocate_buffer_t allocate_buffer,	     \
-			 hurd_slab_deallocate_buffer_t deallocate_buffer,    \
-			 hurd_##name##_slab_constructor_t constructor,	     \
-			 hurd_##name##_slab_destructor_t destructor,	     \
-			 void *hook)					     \
-{									     \
-  union									     \
-  {									     \
-    hurd_##name##_slab_constructor_t t;					     \
-    hurd_slab_constructor_t u;						     \
-  } con;								     \
-  union									     \
-  {									     \
-    hurd_##name##_slab_destructor_t t;					     \
-    hurd_slab_destructor_t u;						     \
-  } des;								     \
-  con.t = constructor;							     \
-  des.t = destructor;							     \
-									     \
-  return hurd_slab_init (&space->space,					     \
-			 sizeof (element_type), __alignof__ (element_type),  \
-			 allocate_buffer, deallocate_buffer,		     \
-			 con.u, des.u, hook);				     \
-}									     \
-									     \
-static inline error_t							     \
-hurd_##name##_slab_destroy (hurd_##name##_slab_space_t space)		     \
-{									     \
-  return hurd_slab_destroy (&space->space);				     \
-}									     \
-									     \
-static inline error_t							     \
-hurd_##name##_slab_alloc (hurd_##name##_slab_space_t space,		     \
-			  element_type **buffer)			     \
-{									     \
-  union									     \
-  {									     \
-    element_type **e;							     \
-    void **v;								     \
-  } foo;								     \
-  foo.e = buffer;							     \
-									     \
-  return hurd_slab_alloc (&space->space, foo.v);			     \
-}									     \
-									     \
-static inline void							     \
-hurd_##name##_slab_dealloc (hurd_##name##_slab_space_t space,		     \
-			    element_type *buffer)			     \
-{									     \
-  union									     \
-  {									     \
-    element_type *e;							     \
-    void *v;								     \
-  } foo;								     \
-  foo.e = buffer;							     \
-									     \
-  hurd_slab_dealloc (&space->space, foo.v);				     \
-}
-
-#endif	/* _HURD_SLAB_H */