arena_lock.h

/* 
 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/>.
*/

#define HAVE_CREATE_ARENA_MUTEX            (01 << 31)


extern struct shm_arena *_shm_default_arena;
extern pthread_mutex_t _shm_create_arena_mutex;


static inline
pthread_rwlock_t *arena_rwlock(const struct shm_arena *a)
{
  return (&(a->header->rwlock));
}



static inline struct shm_arena
*get_arena_min_size(struct shm_arena *a,
            int rwlock_type, /* 1 for read, 2 for write, and 0
                      * for unlock */
            int *err,
            IF_SPEW(const char *func,) size_t min_size)
/* This is used to get the default arena in a thread-safe way.  When
 * it returns successfully you will have the intra-process arena mutex
 * lock, else if it fails you will not.
 * TODO: This is wrong!!! */
{
  if(!a)
    {
      pthread_mutex_lock(&_shm_create_arena_mutex);
       if(!_shm_default_arena)
    {
      if(rwlock_type)
        {
          int flags = 
        O_RDWR | SHM_ARENA_DEFAULT |
        HAVE_CREATE_ARENA_MUTEX;

          if(rwlock_type == 2)
        flags |= O_CREAT;

          shm_arena_create(NULL, flags, SHM_RW_MODE, min_size);
          if(!_shm_default_arena)
        {
          /* It failed */
          *err = errno;
          pthread_mutex_unlock(&_shm_create_arena_mutex);
          return SPEW_SYS_RET(NULL, _WARN,
                      "%s() failed", func);
        }
        }
      else /* rwlock_type == 0 -- unlocking */
        {
          /* It failed */
          pthread_mutex_unlock(&_shm_create_arena_mutex);
          return SPEW_SYS_RET(NULL, _WARN,
                  "%s() failed: the arena object "
                  "has not been created yet", func);
        }
    }
      a = _shm_default_arena;
      pthread_mutex_unlock(&_shm_create_arena_mutex);
    }

  return a;
}

static inline struct shm_arena
*get_arena(struct shm_arena *a,
       int rwlock_type, /* 1 for read, 2 for write, and 0
                 * for unlock */
       int *err
       IF_SPEW(, const char *func))
{
  return get_arena_min_size(a, rwlock_type, err IF_SPEW(, func), 0);
}

static inline struct shm_arena
*get_arena_min_size_and_autolock(struct shm_arena *a,
                 int rwlock_type, /* 1 for read, 2 for write, and 0
                           * for unlock */
                 int *err, /* phread_rwlock_*() error number */
                 IF_SPEW(const char *func,)
                 size_t min_size)
/* arena may be passed in as NULL and this will check and get the
 * arena.  If rwlock_type is 1 the default arena object will be
 * created only if the arena file exists, else if wrlock_type is 2 the
 * default arena object will be created and so will the arena file if
 * it does not exist.  If rwlock_type is 0 the default arena object
 * will not be created, so it must exist already. */
{
  struct rwlock_attr *rwlock;

  ASSERT(rwlock_type == 0 || rwlock_type == 1 || rwlock_type == 2);

  a = get_arena_min_size(a, rwlock_type, err IF_SPEW(, func), min_size);
  if(!a) return a;

  rwlock = get_rwlock_attr(a);

  if(!rwlock)
    return SPEW_RET(NULL, _WARN, "%s() failed: %s() failed",
            func, __func__);

  ASSERT(rwlock->rdlock_count > -1 && rwlock->wrlock_count > -1);

  if(rwlock_type == 2 && rwlock->rdlock_count > 0)
    {
      *err = EINVAL; /* "Invalid argument" this errno sucks */
      return
    SPEW_SYS_RET(NULL, _WARN,
             "%s() failed: you have an arena read-lock"
             " but need an arena write-lock", func);
    }

  if(rwlock_type == 0)
    {
      *err = 0;
      if(rwlock->rdlock_count > 0)
    {
      rwlock->rdlock_count--;
      if(rwlock->rdlock_count == 0)
        *err = pthread_rwlock_unlock(arena_rwlock(a));
    }
      else if(rwlock->wrlock_count > 0)
    {
      rwlock->wrlock_count--;
      if(rwlock->wrlock_count == 0)
        *err = pthread_rwlock_unlock(arena_rwlock(a));
    }
      if(!(*err))
    return a;
      SPEW_SYS(_WARN,
           "%s() failed: pthread_rwlock_unlock() failed",
           func);
      return NULL;
    }

  if(rwlock->wrlock_count > 0)
    {
      rwlock->wrlock_count++;
      return a;
    }
  if(rwlock->rdlock_count > 0)
    {
      rwlock->rdlock_count++;
      return a;
    }

  if(rwlock_type == 1)
    {
      *err = pthread_rwlock_rdlock(arena_rwlock(a));
      if(!(*err))
    {
      rwlock->rdlock_count++;
      return a;
    }
      SPEW_SYS(_WARN,
           "%s() failed: pthread_rwlock_rdlock() failed",
           func);
      return NULL;
    }

  /* rwlock_type == 2 */

  *err = pthread_rwlock_wrlock(arena_rwlock(a));
  if(!(*err))
    {
      rwlock->wrlock_count++;
      return a;
    }
  SPEW_SYS(_WARN,
       "%s() failed: pthread_rwlock_wrlock() failed",
       func);
  return NULL;
}

static inline struct shm_arena
*get_arena_and_autolock(struct shm_arena *a,
            int rwlock_type, /* 1 for read, 2 for write, and 0
                      * for unlock */
            int *err /* phread_rwlock_*() error number */
            IF_SPEW(, const char *func))
{
  return get_arena_min_size_and_autolock(a, rwlock_type,
                     err IF_SPEW(, func),
                     0);
}

static inline int
arena_autounlock(struct shm_arena *a
         IF_SPEW(, const char *func))
/* We must really have an arena object before this call, so we cannot
 * use this in shm_arena_unlock() and shm_unlock() since arena may be
 * NULL for those calls. You must have the intra-process arena mutex
 * before this call. */
{
  int err = 0;
  struct rwlock_attr *rwlock;

  ASSERT(a);

  rwlock = get_rwlock_attr(a);

  if(!rwlock)
    return SPEW_RET(errno, _WARN, "%s() failed: %s() failed",
            func, __func__);

  ASSERT(!(rwlock->rdlock_count > 0 && rwlock->wrlock_count > 0));
  ASSERT(rwlock->rdlock_count > -1 && rwlock->wrlock_count > -1);

  if(rwlock->rdlock_count > 0)
    {
      rwlock->rdlock_count--;
      if(rwlock->rdlock_count == 0)
    err = pthread_rwlock_unlock(arena_rwlock(a));
    }
  else if(rwlock->wrlock_count > 0)
    {
      rwlock->wrlock_count--;
      if(rwlock->wrlock_count == 0)
    err = pthread_rwlock_unlock(arena_rwlock(a));
    }

#ifdef WITH_SPEW
  if(err)
    SPEW_SYS(_WARN,
         "%s() failed: pthread_rwlock_unlock() failed",
         func);
#endif

  return err;
}