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

#ifdef WITH_SPEW
#  define IF_SPEW(...)    __VA_ARGS__
#else
#  define IF_SPEW(...)   /* empty macro, WITH_SPEW not defined */
#endif





#ifdef SHM_DEBUG



/* Turn spew on or off just in this file by selecting one of these two
 * set of defines.  LSPEW stands for Lock SPEW. MSPEW stands to My
 * SPEW. Okay, I drew a blank. */

#if 0 /* 1 for spew on, 0 for spew off */
#  define LSPEW(level, fmt, ...)   SPEW_RET(0, level, fmt, ##__VA_ARGS__ )
#  define MSPEW(level, fmt, ...)   SPEW(level, fmt, ##__VA_ARGS__ )
#else
#  define LSPEW(level, fmt, ...)   (0) /* no spew */
#  define MSPEW(level, fmt, ...)    /* empty macro, no spew */
#endif



/* Set PRETEND_LOCK to use pretend read-write locks and mutexes which
 * do not block the caller like real ones do.  This is for shm-arena
 * development only. */
#if 0
#  define PRETEND_LOCK
#endif

static inline
int shm_rwlock_rdlock(pthread_rwlock_t *rwlock)
{
  int ret;
  MSPEW(_DEBUG, "before rwlock_rdlock");
  ret = pthread_rwlock_rdlock(rwlock);
  MSPEW(_DEBUG, " after rwlock_rdlock");
  ASSERT(!ret);
  return ret;
}

static inline
int shm_rwlock_wrlock(pthread_rwlock_t *rwlock)
{
  int ret;
  MSPEW(_DEBUG, "before rwlock_wrlock");
  ret = pthread_rwlock_wrlock(rwlock);
  MSPEW(_DEBUG, " after rwlock_wrlock");
  ASSERT(!ret);
  return ret;
}

static inline
int shm_rwlock_unlock(pthread_rwlock_t *rwlock)
{
  int ret;
  MSPEW(_DEBUG, "before rwlock_unlock");
  ret = pthread_rwlock_unlock(rwlock);
  MSPEW(_DEBUG, " after rwlock_unlock");
  ASSERT(!ret);
  return ret;
}

static inline
int shm_mutex_lock(pthread_mutex_t *mutex)
{
  int ret;
  MSPEW(_DEBUG, "before mutex_lock");
  ret = pthread_mutex_lock(mutex);
  MSPEW(_DEBUG, " after mutex_lock");
  ASSERT(!ret);
  return ret;
}

static inline
int shm_mutex_unlock(pthread_mutex_t *mutex)
{
  int ret;
  MSPEW(_DEBUG, "before mutex_unlock");
  ret = pthread_mutex_unlock(mutex);
  MSPEW(_DEBUG, " after mutex_unlock");
  ASSERT(!ret);
  return ret;
}

/* Replace the locking and unlocking pthread_*_*lock() calls with our
 * wrappers, without doing anything but including this header file. */

#ifdef PRETEND_LOCK


#define pthread_rwlock_rdlock(x)            \
  LSPEW(_DEBUG, "pthread_rwlock_rdlock(" #x ")")

#define pthread_rwlock_wrlock(x)            \
  LSPEW(_DEBUG, "pthread_rwlock_wrlock(" #x ")")

#define pthread_rwlock_unlock(x)            \
  LSPEW(_DEBUG, "pthread_rwlock_unlock(" #x ")")

#define pthread_mutex_lock(x)                   \
  LSPEW(_DEBUG, "pthread_mutex_lock(" #x ")")

#define pthread_mutex_unlock(x)                 \
  LSPEW(_DEBUG, "pthread_mutex_unlock(" #x ")")


#else /* #ifdef PRETEND_LOCK */


#define pthread_rwlock_rdlock(x)                \
  (LSPEW(_DEBUG, "pthread_rwlock_rdlock(" #x ")")+  \
   shm_rwlock_rdlock((x)))

#define pthread_rwlock_wrlock(x)                \
  (LSPEW(_DEBUG, "pthread_rwlock_wrlock(" #x ")")+  \
   shm_rwlock_wrlock((x)))

#define pthread_rwlock_unlock(x)                \
  (LSPEW(_DEBUG, "pthread_rwlock_unlock(" #x ")")+  \
   shm_rwlock_unlock((x)))

#define pthread_mutex_lock(x)               \
  (LSPEW(_DEBUG, "pthread_mutex_lock(" #x ")")+     \
   shm_mutex_lock((x)))

#define pthread_mutex_unlock(x)             \
  (LSPEW(_DEBUG, "pthread_mutex_unlock(" #x ")")+   \
   shm_mutex_unlock((x)))


#endif /* #ifdef PRETEND_LOCK */



#endif /* #ifdef SHM_DEBUG */