lock.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 <errno.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.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"


int shm_arena_wrlock(shm_arena_t arena)
{
  int err;
  //SPEW(_DEBUG, "%s(arena=%p)", __func__, arena);

  arena = get_arena_and_autolock(arena, 2, &err IF_SPEW(, __func__));
  if(!arena)
    {
      return (errno = err);
    }
  
  return 0;
}

int shm_arena_rdlock(shm_arena_t arena)
{
  int err;
  //SPEW(_DEBUG, "%s(arena=%p)", __func__, arena);

  arena = get_arena_and_autolock(arena, 1, &err IF_SPEW(, __func__));
  if(!arena)
    {
      return (errno = err);
    }

  return 0;
}

int shm_arena_unlock(shm_arena_t arena)
{
  int err;
  //SPEW(_DEBUG, "%s(arena=%p)", __func__, arena);

  arena = get_arena_and_autolock(arena, 0, &err IF_SPEW(, __func__));
  if(!arena)
      return (errno = err);

  return 0;
}

int shm_wrlock(shm_arena_t arena, const void *ptr)
{
  int err = 0;
  pthread_rwlock_t *l;

  //SPEW(_DEBUG, "%s(arena=%p, ptr=%p)", __func__, arena, ptr);

  arena = get_arena_and_autolock(arena, 1, &err IF_SPEW(, __func__));
  if(!arena)
    {
      return err;
    }
  if((l = ptr_rwlock(ptr)))
    {
      err = pthread_rwlock_wrlock(l);
      if(err)
    {
      errno = err;
      SPEW_SYS(_WARN,
           "%s() failed: pthread_rwlock_wrlock() failed",
           __func__);
    }
    }

  return err;
}


int shm_rdlock(shm_arena_t arena, const void *ptr)
{
  int err = 0;
  pthread_rwlock_t *l;

  //SPEW(_DEBUG, "%s(arena=%p, ptr=%p)", __func__, arena, ptr);

  arena = get_arena_and_autolock(arena, 1, &err IF_SPEW(, __func__));
  if(!arena)
    {
      return err;
    }

  if((l = ptr_rwlock(ptr)))
    {
      err = pthread_rwlock_rdlock(l);
      if(err)
    {
      errno = err;
      SPEW_SYS(_WARN,
           "%s() failed: pthread_rwlock_rdlock() failed",
           __func__);
    }
    }

  return err;
}

int shm_unlock(shm_arena_t arena, const void *ptr)
{
  int err = 0;
  pthread_rwlock_t *l;

  //SPEW(_DEBUG, "%s(arena=%p, ptr=%p)", __func__, arena, ptr);

  arena = get_arena(arena, 1, &err IF_SPEW(, __func__));
  if(!arena)
    {
      return err;
    }

  if((l = ptr_rwlock(ptr)))
    {
      err = pthread_rwlock_unlock(l);
      if(err)
    {
      errno = err;
      SPEW_SYS(_WARN,
           "%s() failed: pthread_rwlock_unlock() failed",
           __func__);
    }
    }

  if(!err)
    err = arena_autounlock(arena IF_SPEW(, __func__));
  else
    arena_autounlock(arena IF_SPEW(, __func__));

  return err;
}


int shm_rwlock_reset(shm_arena_t arena, const void *ptr)
{
  int err = 1;
  /* For now keep gcc from complaining about unused variables: */
  if(arena) return err;
  if(ptr) return err;
#if 0
  pthread_rwlock_t *l;
 
  //SPEW(_DEBUG, "%s(arena=%p, ptr=%p)", __func__, arena, ptr);

  arena = get_arena_and_autolock(arena, 1, &err IF_SPEW(, __func__));
  if(!arena)
    {
    return err;
    }
  if((l = ptr_rwlock(ptr))
    {
      err = pthread_rwlock_rdlock(l);
      if(err)
    {
      errno = err;
      SPEW_SYS(_WARN,
           "%s() failed: pthread_rwlock_rdlock() failed",
           __func__);
    }
    }
#endif

  return err;
}

int shm_arena_rwlock_reset(shm_arena_t arena)
{
  /* For now keep gcc from complaining about unused variables: */
  if(arena) return 1;
#if 0
  int err;
  SPEW(_DEBUG, "%s(arena=%p)", __func__, arena);

  arena = get_arena(arena, 2, &err IF_SPEW(, __func__));
  if(!arena)
    {
      return (errno = err);
    }

#endif
  return 1;
}