arena.c

/* 
 shm-arena    shared memory arena
 Copyright (C) 2006-2008 Lance Arsenault (LGPL v3)


    This file is part of shm-arena.

    shm-arena 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 3 of the
    License, or (at your option) any later version.

    shm-arena 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, see
    <http://www.gnu.org/licenses/>.
*/

#include "config.h"
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <inttypes.h>
#include <sys/file.h>
#include <sys/mman.h>
#include <stdint.h>

#include <pthread.h>
#include "spew.h"
#include "assert.h"
#include "debug_lock.h"
#include "shm_arena.h"
#include "arena.h"
#include "arena_lock.h"
#include "avl.h"


#define IS_FULL_PATH(x)  ((x)&&(x)[0]==DIR_CHAR&&(x)[1])

struct shm_arena *_shm_default_arena = NULL;
pthread_mutex_t _shm_create_arena_mutex = PTHREAD_MUTEX_INITIALIZER;

/* list of all arenas.  Protected by _shm_create_arena_mutex. */
static int num_arenas = 0; /* array length */
static struct shm_arena **arenas; /* array of all arenas allocated. */
static int atfork_set = 0; /* atfork callbacks are set up. */


static void prefork(void)
/* called before fork() if there is or were any arena objects. */
{
  int i;
  for(i=0;i<num_arenas;i++)
    {
      /* To avoid deadlock we must as a rule get the arena file write
       * (or read) lock and hold it before the mutex locks, and not
       * the other way around.  That's what happens in shm_get(),
       * shm_remove() and the other shared memory segment
       * functions. */
      /* This must be a write lock in order to stop any segment
       * inter-process arena file read or write lock calls. */
      pthread_rwlock_wrlock(arena_rwlock(arenas[i]));
      pthread_mutex_lock(&arenas[i]->rwlock_mutex);
      pthread_mutex_lock(&arenas[i]->mapping_mutex);
    }
  pthread_mutex_lock(&_shm_create_arena_mutex);
}

static void parent_postfork(void)
/* called after fork() by the parent if there is or were any arena
 * objects. */
{
  int i;
  pthread_mutex_unlock(&_shm_create_arena_mutex);
  for(i=0;i<num_arenas;i++)
    {
      pthread_mutex_unlock(&arenas[i]->mapping_mutex);
      pthread_mutex_unlock(&arenas[i]->rwlock_mutex);
      pthread_rwlock_unlock(arena_rwlock(arenas[i]));
    }
}

static void child_postfork(void)
/* called after fork() by the child if there is or were any arena
 * objects. */
{
  int i;
  pthread_mutex_unlock(&_shm_create_arena_mutex);
  for(i=0;i<num_arenas;i++)
    {
      struct rwlock_attr *attr;
      /* Reset any rwlock flags that may have been passed down from
       * the parent process. */
      attr = (struct rwlock_attr *)
    pthread_getspecific(arenas[i]->rwlock_key);
      if(attr)
    {
      attr->rdlock_count = 0;
      attr->wrlock_count = 0;
    }

      pthread_mutex_unlock(&arenas[i]->mapping_mutex);
      pthread_mutex_unlock(&arenas[i]->rwlock_mutex);
      /* Do we inherit this inter-process lock from the parent?  The
       * answer is NO.  So we do not call
       * pthread_rwlock_unlock(arena_rwlock(arenas[i])); */
    }
}


/* return 0 on success, returns system errno on error or -1 if not a
 * sys error. */
static int rec_mkdir(const char *dir, mode_t mode)
{
  /* directory require execute permission */
  mode |= (S_IXUSR|S_IXGRP|S_IXOTH);

  if(!mkdir(dir, mode))
    return SPEW_RET(0, _DEBUG, "Made directory \"%s\".", dir);

  char *parent_dir = strdup(dir);
  if(!parent_dir)
    return SPEW_RET(errno?errno:ENOMEM, _WARN,
            "malloc() failed");

  {
    char *s;
    s = parent_dir;
    for(;*s;s++);

    for(;*s != DIR_CHAR && s != parent_dir; s--);
    *s = '\0';
  }

  if(*parent_dir == '\0')
    {
      free(parent_dir);
      return 0;
    }

  struct stat st;
  int i = stat(parent_dir,&st);
  if(i && errno == ENOENT && !rec_mkdir(parent_dir, mode))
    // parent_dir did not exist and we made it by recursing.
    {
      free(parent_dir);
      if(!mkdir(dir, mode))
        return SPEW_RET(0, _DEBUG, "Made directory \"%s\".", dir);
      else
        return SPEW_RET(errno?errno:-1,
            _WARN, "mkdir(\"%s\", mode=0%o) failed:", dir, mode);
    }

  if(i == 0) // this part of the path exists
    {
      if(S_ISDIR(st.st_mode))
        {
          free(parent_dir);
          return 0;
        }
      else
        {
          SPEW(_WARN, "Failed to make directory \"%s\" because the file"
           " \"%s\" exists"
           " and is not a directory.", dir, parent_dir);
          free(parent_dir);
          return -1;
        }
    }

  free(parent_dir);
  return SPEW_RET(-1, _WARN, "Failed to make directory \"%s\".", dir);
}

#ifdef WITH_SPEW
# define STRCPY(x,y)  strcpy(x,y)
#else
# define STRCPY(x,y)  /* empty macro */
#endif

/* Find the shared memory arena file path */
/* return 0 on success, return errno on error.  alloc_path_out will
 * point to the malloc() allocated string or NULL on failure. */
static int
arena_path(const char *path, int *flags, char **alloc_path_out)
{
  char *apath = NULL;
  char *dir = NULL;
  char *file = NULL;

  *alloc_path_out = NULL;

  if(!path || !(path[0]))
    {
      file = getenv("SHM_DEFAULT_ARENA_FILE");
      if(!file)
    file = SHM_DEFAULT_ARENA_FILE;
    }
  else
    file = (char *) path;

#if 0 /* let shm_open() fail if it wants to. */
  if((flags) &&
     ((*flags) & SHM_WITH_SHM_OPEN) 
     && IS_FULL_PATH(file)
     && strncmp("/dev/shm/", file, 9))
    /* This is a bad path that should start with /dev/shm/ or not a
     * full path. */
    return EINVAL; /* "Invalid argument" */
#endif

  if(!strncmp("/dev/shm/", file, 9))
    {
      if(flags)
    (*flags) |= SHM_WITH_SHM_OPEN;
      file += 9; /* strip off the /dev/shm/ shm_open() does not like
          * it. */
      if(!file[0])
    return EINVAL; /* "Invalid argument" */
    }

  if((flags && ((*flags) & SHM_WITH_SHM_OPEN)) || IS_FULL_PATH(file))
    {
      apath = strdup(file);
      if(!apath) return ENOMEM;
      *alloc_path_out = apath;
      return 0;
    }

  dir = getenv("SHM_DEFAULT_ARENA_DIR");
  if(!dir)
    dir = SHM_DEFAULT_ARENA_DIR;

  if(!strncmp("/dev/shm", dir, 8))
    {
      if(flags)
    (*flags) |= SHM_WITH_SHM_OPEN;
      dir += 8; /* strip off the /dev/shm shm_open() does not like
          * it. */
      if(dir[0] == DIR_CHAR)
    dir++;
    }

  if(dir[0])
    {
      apath = (char *) 
    malloc(strlen(dir) + strlen(DIR_STRING) + strlen(file) + 1);
      if(!apath) return ENOMEM;
      sprintf(apath, "%s"DIR_STRING"%s", dir, file);
      *alloc_path_out = apath;
    }
  else
    {
      apath = strdup(file);
      if(!apath) return ENOMEM;
      *alloc_path_out = apath;
    }

  return 0;
}

/* cleans up memory for the pre-thread pre-arena object automatic
 * arena read-write locks.  See struct rwlock_attr in arena.h. */
static void rwlock_attr_destructor(void *ptr)
{
  SPEW(_INFO, "%s(ptr=%p)", __func__, ptr);
  if(ptr)
    free(ptr); /* frees a struct rwlock_attr */
}


shm_arena_t shm_arena_create(const char *path, int flags, mode_t mode,
                 size_t min_size)
{
  struct stat st;
  char *apath = NULL;   /* allocated path if we have too */
  int err = 0;          /* will be errno if needed */
#ifdef WITH_SPEW
  char err_str[64] = "";
#endif
  uint32_t arena_flags = 0;

  int fd = -1;
  void *start = MAP_FAILED;
  size_t map_length = 0;
  struct shm_arena *arena = NULL;
  pthread_rwlock_t *rwlock = 0;
  int have_flock = 0; /* got the flock here in this function */
  void *user_shm_address = NULL;

  SPEW(_INFO, "%s(path=\"%s\", flags=%d, mode=0%o, min_size=%zu)",
       __func__, path, flags, mode, min_size);

  /* find the path to the arena file */
  if(!(flags & SHM_USE_GIVEN_PATH))
    err = arena_path(path, &flags, &apath);
  else if(path == NULL || !path[0])
    {
      errno = ENOENT; /* "No such file or directory" */
      SPEW(_WARN, "Bad path \"%s\"\n", path);
      return NULL;
    }

  if(err)
    {
      errno = err;
      SPEW(_WARN, "Can't use arena file path");
      return NULL;
    }

  if(apath) path = apath;

  /* save these flags for later below. */
  arena_flags =
    (SHM_WITH_SHM_OPEN |
     SHM_USE_GIVEN_PATH |
     SHM_ARENA_DEFAULT |
     HAVE_CREATE_ARENA_MUTEX |
     SHM_ARENA_HAVE_FLOCK) & flags;

  /* creation flags are:

    0               = just connect
    O_CREAT         = create and connect or just connect
    O_CREATE|O_EXCL = create and connect

    that is or'd with the SHM_WITH_SHM_OPEN bit flag
  */

  {
    /************************* handle env SHM_ADDRESS ***********************/
    char *shm_address;
    shm_address = getenv("SHM_ADDRESS");
    if(shm_address)
    {
      unsigned long val;
      errno = 0;
      val = strtoul(shm_address, NULL, 16);
      if(errno || val == 0)
      {
    errno = EFAULT;
    SPEW(_WARN, "Invalid env SHM_ADDRESS");
    return NULL;
      }
      user_shm_address = (void*) val;
    }
  }


  /* At this point the path is okay to use */

  if(!(arena_flags & HAVE_CREATE_ARENA_MUTEX))
    pthread_mutex_lock(&_shm_create_arena_mutex);


  if(!(SHM_WITH_SHM_OPEN & flags) && flags & O_CREAT)
    {
      /* Here we'll check that the directory part of path is made. */
      char *dir = strdup(path);
      if(!dir)
    {
      err = ENOMEM;
      goto arena_error;
    }
      {
    char *s;
    s = dir;
    for(;*s;s++);
    for(;*s != DIR_CHAR && s != dir;s--);
    *s = '\0';
    if(*dir && rec_mkdir(dir, mode))
      {
        free(dir); 
        err = EACCES; /* Permission denied */
        STRCPY(err_str, ": Can't make directory");
        goto arena_error;
      }
      }
      free(dir);
    }

  /* At this point the directory part exists, or if it does not it
   * will give the user the well earned error for not setting O_CREAT
   * in flags. */

  flags &= 0x00FFFFFF; /* strip shm_arena specfic flags */

  if(SHM_WITH_SHM_OPEN & arena_flags)
    fd = shm_open(path, flags, mode);
  else
    fd = open(path, flags, mode);

  if(fd == -1)
    {
      err = errno;
#ifdef WITH_SPEW
      if(SHM_WITH_SHM_OPEN & arena_flags)
    STRCPY(err_str, ": shm_open() failed");
      else
    STRCPY(err_str, ": open() failed");
#endif
      goto arena_error;
    }

  if(!(arena_flags & SHM_ARENA_HAVE_FLOCK))
    {
      if(flock(fd, LOCK_EX))
    {
      err = errno;
      STRCPY(err_str, ": Can't flock(fd, LOCK_EX) file");
      goto arena_error;
    }
      have_flock = 1;
    }

  if(fstat(fd, &st))
    {
      err = errno;
      STRCPY(err_str, ": Can't stat file");
      goto arena_error;
    }

  if(st.st_size > 0 &&
     st.st_size < (off_t) (CHUNKS(sizeof(struct arena_header)) +
               CHUNKS(sizeof(struct mapping_header))))
    {
      /* The file existed before we opened it and it's not big enough*/
      /* EMEDIUMTYPE 124  "Wrong medium type" is the best I see. */
      STRCPY(err_str, ": existing file not big enough");
      err = EMEDIUMTYPE;
      goto arena_error;
    }

  if(st.st_size > 0)
    {
      ssize_t ret;
      struct arena_header shm;
      
      /* We need the mapping size before we can map the file. */
      ret = read(fd, &shm, sizeof(struct arena_header));
      if(ret == -1)
    {
      STRCPY(err_str, ": read() failed");
      err = errno;
      goto arena_error;
    }
      if((size_t) ret < sizeof(struct arena_header))
    {
      STRCPY(err_str, ": Can't read file");
      err = EMEDIUMTYPE;
      goto arena_error;
    }
      if(shm.magic != ARENA_MAGIC)
    {
      STRCPY(err_str, ": Bad magic number in file");
      err = EMEDIUMTYPE;
      goto arena_error;
    }

      if((shm.flags & SHM_WITH_SHM_OPEN) != (arena_flags & SHM_WITH_SHM_OPEN))
    {
#ifdef WITH_SPEW
      if(arena_flags & SHM_WITH_SHM_OPEN)
        STRCPY(err_str, ": Arena file not using shm_open(), "
           "but is requested");
      else
        STRCPY(err_str, ": Arena file is using shm_open(), "
           "but is not requested");
#endif
      err = EMEDIUMTYPE;
      goto arena_error;
    }
      if(lseek(fd, 0, SEEK_SET) == -1)
    {
      STRCPY(err_str, ": lseek(fd, 0, SEEK_SET) failed");
      err = errno;
      goto arena_error;
    }
       map_length = shm.map_header.map_length * CHUNK;

     /********* Now we connect to the arena, mmap() *********/

      start = mmap(user_shm_address, map_length,
      PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
      if(start == MAP_FAILED)
    {
      STRCPY(err_str, ": mmap() failed");
      err = errno;
      goto arena_error;
    }
      if(user_shm_address && user_shm_address != start)
      {
    /* The user had env SHM_ADDRESS set and we failed
     * to map to that address. */
#ifdef WITH_SPEW
    sprintf(err_str, ": mmap()=%p failed "
        "with SHM_ADDRESS=%p", start, user_shm_address);
#endif
    err = EFAULT;
    goto arena_error;
      }

      rwlock = &(((struct arena_header *)start)->rwlock);
      if((err = pthread_rwlock_rdlock(rwlock)))
       {
     rwlock = NULL; /* we don't have a read lock */
     STRCPY(err_str, ": pthread_rwlock_rdlock() failed");
     goto arena_error;
       }
      /* we have a read lock now */
    }
 else /* file size is now zero, we need to build it */
   {
     struct arena_header *header;
     pthread_rwlockattr_t attr;
     size_t file_length;

     if(min_size < 1) min_size = 1;

     /* file_length will start out smaller than  map_length */
     file_length = CHUNKS(sizeof(struct arena_header)) +
       CHUNKS(sizeof(struct mapping_header));
     map_length = PAGES(file_length +
            CHUNKS(sizeof(struct seg_header)) +
            CHUNKS(min_size) +
            CHUNKS(sizeof(pthread_rwlock_t)) +
            CHUNKS(16) + /* for the name string */
            CHUNKS(sizeof(struct seg_footer)),
            getpagesize()
            );

     header = (struct arena_header *)
       (start = mmap(user_shm_address, map_length,
      PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0));

     if(start == MAP_FAILED)
       {
     STRCPY(err_str, ": mmap() failed");
     err = errno;
     goto arena_error;
       }

     /* We must make the file have some length even if
      * mmap() mapped to the wrong address so that we
      * can see if header->magic was set without a
      * memory fault in the error cleanup below. */
     if(ftruncate(fd, file_length))
       {
#ifdef WITH_SPEW
     sprintf(err_str, ": ftruncate(fd=%d, length=%zu) failed",
         fd, file_length);
#endif
     if(user_shm_address)
      {
        /* We must unmap the memory now since the cleanup
         * below assumes the memory is not zero length if
         * start not equal to MAP_FAILED. */
        munmap(start, map_length);
        /* Keep start from being accessed at cleanup
         * below. */
        start =  MAP_FAILED;
      }
     err = errno;
     goto arena_error;
       }

    if(user_shm_address && user_shm_address != start)
      {
    /* The user had env SHM_ADDRESS set and we failed
     * to map to that address. */
#ifdef WITH_SPEW
    sprintf(err_str, ": mmap()=%p failed "
        "with SHM_ADDRESS=%p", start, user_shm_address);
#endif
    err = EFAULT;
    goto arena_error;
      }

     if((err = pthread_rwlockattr_init(&attr)))
       {
     STRCPY(err_str, ": pthread_rwlockattr_init() failed");
     goto arena_error;
       }
     if((err = pthread_rwlockattr_setpshared(&attr, PTHREAD_PROCESS_SHARED)))
       {
     STRCPY(err_str, ": pthread_rwlockattr_setpshared() failed");
     goto arena_error;
       }
     if((err = pthread_rwlock_init(&header->rwlock, &attr)))
       {
     STRCPY(err_str, ": pthread_rwlock_init() failed");
     goto arena_error;
       }
     if((err = pthread_rwlock_wrlock(&(header->rwlock))))
       {
     STRCPY(err_str, ": pthread_rwlock_rdlock() failed");
     goto arena_error;
       }
     /* we have the arena write lock */
     rwlock = &(header->rwlock);

     /* this is the flags that are saved in the arena header */
     header->flags = (arena_flags & SHM_WITH_SHM_OPEN);

     /* the change_count in the shared memory starts at 1. */
     header->change_count = 1;
     header->name_count = 0;
     header->num_mappings = 1;
     header->free_mapnum = -1;
     header->alloc_mapnum = -1;
     header->free_offset = 0;
     header->alloc_offset = 0;

     /* Setup the first mapping struct */
     header->map_header.map_length = map_length/CHUNK;
     header->map_header.length_used = file_length/CHUNK;

     { /* The second mapping struct starts life zero-ed. */
       struct mapping_header *map_header;

       map_header = (struct mapping_header *)
     (start + CHUNKS(sizeof(struct arena_header)));
       map_header->map_length = 0;
       map_header->length_used = 0;
     }
   }

  /* At this point if the magic number in the mapped file is set we
   * are connecting to the arena, else we are creating it. */

  arena = (struct shm_arena *) malloc(sizeof(struct shm_arena));
  if(!arena)
    {
      err = errno;
      goto arena_error;
    }

  /* Assuming the malloc() and pthread_rwlock_unlock() below do not
   * fail this is a good time to spew what happened. */
  SPEW(_DEBUG, "%s(): %s %sshared memory arena \"%s\"",
       __func__,
       (((struct arena_header *)start)->magic != ARENA_MAGIC)?
       "created":"connected to",
       arena_flags&SHM_WITH_SHM_OPEN?"shm_open type ":"",
       path);


  /**************************************************/
  /* Initialize the local allocated arena structure */
  /**************************************************/
  arena->fd = fd;
  arena->num_mappings =
    ((struct arena_header *) start)->num_mappings;
  arena->change_count = 0;
  arena->user_shm_address = user_shm_address;

  arena->header = (struct arena_header *) start;

  if((err = pthread_key_create(&arena->rwlock_key,
                   rwlock_attr_destructor)))
    {
      STRCPY(err_str, ": pthread_key_create() failed");
      goto arena_error;
    }
  if((err = pthread_mutex_init(&arena->mapping_mutex, NULL)))
    {
      STRCPY(err_str, ": pthread_mutex_init() failed");
      goto arena_error;
    }
  if((err = pthread_mutex_init(&arena->rwlock_mutex, NULL)))
    {
      STRCPY(err_str, ": pthread_mutex_init() failed");
      goto arena_error;
    }

  arena->mapping = (struct shm_mapping *)
    malloc(arena->num_mappings*sizeof(struct shm_mapping));
  if(!(arena->mapping))
    {
      err = errno;
      goto arena_error;
    }

  arena->mapping[0].start = start;
  arena->mapping[0].map_length = map_length/CHUNK;

  SPEW(_INFO, "mapped %p -> %p  %zu bytes",
    arena->mapping[0].start,
    (void*)(((uintptr_t)arena->mapping[0].start)+
      arena->mapping[0].map_length*CHUNK),
    arena->mapping[0].map_length*CHUNK);

  {
    int i;
    off_t total_len;
    struct mapping_header *header;

    for(i=1; i<arena->num_mappings; i++)
      arena->mapping[i].start = MAP_FAILED;

    header = (struct mapping_header *)
      (((uint8_t *)start) + CHUNKS(sizeof(struct arena_header)));
    total_len = map_length;

    /* connect to all the mappings after the first */
    for(i=1; i<arena->num_mappings; i++)
      {
    size_t len;

    len = header->map_length * CHUNK;
    if(user_shm_address)
      user_shm_address =
        (void*)(((uintptr_t)user_shm_address +
          arena->mapping[i-1].map_length*CHUNK));

    arena->mapping[i].start = mmap(user_shm_address, len,
          PROT_READ|PROT_WRITE, MAP_SHARED, fd, total_len);
    if(arena->mapping[i].start == MAP_FAILED)
      {
        STRCPY(err_str, ": mmap() failed");
        err = errno;
        goto arena_error;
      }
    if(user_shm_address &&
        user_shm_address != arena->mapping[i].start)
      {
        STRCPY(err_str, ": mmap() failed with SHM_ADDRESS set");
        err = EFAULT;
        goto arena_error;
      }

    SPEW(_INFO, "mapped %p -> %p  %zu bytes",
        arena->mapping[i].start,
        (void*)(((uintptr_t)arena->mapping[i].start)+len),
        len);

    arena->mapping[i].map_length = header->map_length;
    total_len += len;

    header = (struct mapping_header *) arena->mapping[i].start;
      }
  }

  

  if(((struct arena_header *)start)->magic != ARENA_MAGIC)
    {
      /* We created the arena file so we mark it with magic */
      ((struct arena_header *)start)->magic = ARENA_MAGIC;
      if((err = pthread_rwlock_unlock(rwlock)))
    {
      ((struct arena_header *)start)->magic = 0;
      STRCPY(err_str, ": pthread_rwlock_unlock() failed");
      goto arena_error;
    }
      else
    arena->change_count =
      ((struct arena_header *)start)->change_count;
    }
  else /* We didn't create the arena file */
    {
      if((err = pthread_rwlock_unlock(rwlock)))
    {
      /* don't unset arena magic number because we didn't create the
       * arena */
      STRCPY(err_str, ": pthread_rwlock_unlock() failed");
      goto arena_error;
    }
      arena->change_count =
    ((struct arena_header *)start)->change_count;
    }

  /* Set the default arena if there is not one or we are told to with
   * flags. */
  if(_shm_default_arena == NULL || arena_flags & SHM_ARENA_DEFAULT)
    {
      _shm_default_arena = arena;
      SPEW(_DEBUG, "Made this new arena object the default "
      "arena object");
    }

  /* Make this code thread-safe at a fork call */
  if(!atfork_set)
    {
      if((err = pthread_atfork(prefork,
          parent_postfork, child_postfork)))
    {
      STRCPY(err_str, ": pthread_atfork() failed");
      goto arena_error;
    }
      atfork_set = 1;
    }

  num_arenas++;
  arenas = (struct shm_arena **)
    realloc(arenas, sizeof(struct shm_arena *)*num_arenas);
  if(!arenas)
    {
      err = errno;
      num_arenas = 0;
      STRCPY(err_str, ": realloc() failed");
      goto arena_error;
    }
  arenas[num_arenas-1] = arena;

  if(have_flock && flock(fd, LOCK_UN))
    {
      err = errno;
      STRCPY(err_str, ": flock(fd, LOCK_UN) failed");
      goto arena_error;
    }

  if(!(arena_flags & HAVE_CREATE_ARENA_MUTEX))
    pthread_mutex_unlock(&_shm_create_arena_mutex);
 
  if(apath)
    {
      free(apath);
      apath = NULL;
    }

  return arena;


 arena_error:

  errno = err;

  SPEW_SYS(_WARN, "%s() failed%s: failed "
       "to attach to shared memory file \"%s\"",
       __func__, err_str, path);

  if(start != MAP_FAILED &&
      ((struct arena_header *)start)->magic != ARENA_MAGIC)
    {
      /* We failed to create the arena file so we'll remove it now. */
      if(arena_flags & SHM_WITH_SHM_OPEN)
    shm_unlink(path);
      else
    unlink(path);
    }

  if(arena && arena->mapping)
    {
      while(arena->num_mappings > 0)
    {
      if(arena->mapping[arena->num_mappings-1].start != MAP_FAILED)
        {
          struct mapping_header *header;
          header = (struct mapping_header *)
        arena->mapping[arena->num_mappings-1].start;

          munmap(arena->mapping[arena->num_mappings-1].start,
          header->map_length);
        }

      (arena->num_mappings)--;
    }

      free(arena->mapping);
    }
  else if(start != MAP_FAILED)
      munmap(start, map_length);

  if(rwlock)
    pthread_rwlock_unlock(rwlock);

  /* the top (first) arena mapping */
  if(start != MAP_FAILED)
    munmap(start, map_length);

  if(have_flock && fd != -1)
    flock(fd, LOCK_UN);

  if(fd != -1) close(fd);

  if(apath) free(apath);
  if(arena)
    {
      free(arena);
      arena = NULL;
    }

  if(!(arena_flags & HAVE_CREATE_ARENA_MUTEX))
   pthread_mutex_unlock(&_shm_create_arena_mutex);

  return arena;
}

int shm_arena_delete(shm_arena_t arena)
{
  int ret = 0;
  int err = 0;
  void *ptr;

  SPEW(_INFO, "%s(arena=%p)", __func__, arena);

  arena = get_arena(arena, 1, &err IF_SPEW(, __func__));

  if(!arena)
    {
      errno = err;
      return -1;
    }

  pthread_mutex_lock(&_shm_create_arena_mutex);

  /* We can clean it up for this thread now. */
  if((ptr = pthread_getspecific(arena->rwlock_key)))
    {
      free(ptr);
      /* This will keep the memory from being freed twice. */
      pthread_setspecific(arena->rwlock_key, NULL);
    }

  while(arena->num_mappings)
    {
      arena->num_mappings--;
      if(munmap(arena->mapping[arena->num_mappings].start,
        arena->mapping[arena->num_mappings].map_length*CHUNK))
    {
      ret = -1;
      SPEW_SYS(_WARN, "%s() failed: munmap() mapping number="
           MAPNUM_FORMAT " failed",
           __func__, arena->num_mappings);
    }
    }

  if(arena->mapping)
    {
      free(arena->mapping);
      /* We set the memory incase things go to hell they will not get
       * to far.  Setting it to a bad value will make it crash faster
       * in most cases. */
      arena->mapping = NULL;
    }

  if(arena->fd != -1)
    {
      close(arena->fd);
      arena->fd = -1;
    }

  num_arenas--;
  if(num_arenas)
    {
      arenas = (struct shm_arena **)
    realloc(arenas, sizeof(struct shm_arena *)*num_arenas);
      if(!arenas)
    {
      num_arenas = 0;
      /* realloc() failed so we are screwed, return error anyway. */
      ret = -1;
    }
    }
  else
    {
      free(arenas);
      arenas = NULL;
    }

  if(arena != _shm_default_arena)
    {
      pthread_mutex_unlock(&_shm_create_arena_mutex);
      free(arena);
      arena = NULL;
      return ret;
    }

  _shm_default_arena = NULL;
  pthread_mutex_unlock(&_shm_create_arena_mutex);

  free(arena);
  arena = NULL;

  return ret;
}

int shm_arena_destroy(const char *path, int flags)
{
  char *apath = NULL; /* allocated path */
  int ret = -1;
  int fd = -1;
  struct arena_header a_hdr;

  SPEW(_INFO, "%s(\"%s\", flags=%d)", __func__, path, flags);

  if((!(flags & SHM_USE_GIVEN_PATH)) &&
     arena_path(path, &flags, &apath))
    goto finish0; /* error */

  if(flags & SHM_USE_GIVEN_PATH && (path == NULL || !path[0]))
    {
      errno = ENOENT; /* "No such file or directory" */
      SPEW(_WARN, "Bad path \"%s\"\n", path);
      goto finish0; /* error */
    }

  if(apath) path = apath;

  if(flags & SHM_WITH_SHM_OPEN)
    fd = shm_open(path, O_RDONLY, SHM_RW_MODE);
  else
    fd = open(path, O_RDONLY);

  if(fd == -1)
    {
      SPEW_SYS(_WARN, "%s() failed to %sopen \"%s\"",
           __func__,
           (flags & SHM_WITH_SHM_OPEN)?"SHM_":"", path);
      goto finish0;
    }
  if(read(fd, &a_hdr, sizeof(a_hdr)) != sizeof(a_hdr))
    {
      SPEW_SYS(_WARN, "%s() failed to read \"%s\"",
           __func__, path);
      goto finish1;
    }

  if(a_hdr.flags & SHM_WITH_SHM_OPEN)
    {
      /* It's likely that shm_unlink() and unlink() are the same on
       * Linux systems, but in keeping with POSIX bullshit we use
       * shm_unlink(): */
      ret = shm_unlink(path);
    }
  else
    ret = unlink(path);


 finish1:

  if(fd != -1)
    close(fd);

 finish0:

#ifdef WITH_SPEW
  if(ret == 0)
    SPEW(_INFO, "Removed %sarena file \"%s\"",
     (flags & SHM_WITH_SHM_OPEN)?"/dev/shm ":"", path);
  else
    SPEW(_INFO, "Failed to remove %sarena file \"%s\"",
     (flags & SHM_WITH_SHM_OPEN)?"/dev/shm ":"", path);
#endif

  if(apath)
    free(apath);

  return ret;
}