* Copyright 2009, Michael Lotz, mmlr@mlotz.ch.
* Distributed under the terms of the MIT License.
*/
#ifndef _LOCKS_H_
#define _LOCKS_H_
#include <OS.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct mutex {
const char* name;
int32 lock;
uint32 flags;
} mutex;
#define MUTEX_FLAG_CLONE_NAME 0x1
#define MUTEX_FLAG_ADAPTIVE 0x2
#define MUTEX_INITIALIZER(name) { name, 0, 0 }
#define mutex_init(lock, name) __mutex_init(lock, name)
#define mutex_init_etc(lock, name, flags) __mutex_init_etc(lock, name, flags)
#define mutex_destroy(lock) __mutex_destroy(lock)
#define mutex_lock(lock) __mutex_lock(lock)
#define mutex_unlock(lock) __mutex_unlock(lock)
void __mutex_init(mutex *lock, const char *name);
void __mutex_init_etc(mutex *lock, const char *name, uint32 flags);
void __mutex_destroy(mutex *lock);
status_t __mutex_lock(mutex *lock);
void __mutex_unlock(mutex *lock);
typedef struct rw_lock {
mutex lock;
struct rw_lock_waiter * waiters;
struct rw_lock_waiter * last_waiter;
thread_id holder;
int32 reader_count;
int32 writer_count;
int32 owner_count;
} rw_lock;
#define RW_LOCK_FLAG_CLONE_NAME MUTEX_FLAG_CLONE_NAME
#define RW_LOCK_INITIALIZER(name) { MUTEX_INITIALIZER(name), NULL, \
NULL, -1, 0, 0, 0 }
#define rw_lock_init(lock, name) __rw_lock_init(lock, name)
#define rw_lock_init_etc(lock, name, flags) \
__rw_lock_init_etc(lock, name, flags)
#define rw_lock_destroy(lock) __rw_lock_destroy(lock)
#define rw_lock_read_lock(lock) __rw_lock_read_lock(lock)
#define rw_lock_read_unlock(lock) __rw_lock_read_unlock(lock)
#define rw_lock_write_lock(lock) __rw_lock_write_lock(lock)
#define rw_lock_write_unlock(lock) __rw_lock_write_unlock(lock)
void __rw_lock_init(rw_lock *lock, const char *name);
void __rw_lock_init_etc(rw_lock *lock, const char *name, uint32 flags);
void __rw_lock_destroy(rw_lock *lock);
status_t __rw_lock_read_lock(rw_lock *lock);
status_t __rw_lock_read_unlock(rw_lock *lock);
status_t __rw_lock_write_lock(rw_lock *lock);
status_t __rw_lock_write_unlock(rw_lock *lock);
typedef struct recursive_lock {
mutex lock;
thread_id holder;
int32 recursion;
} recursive_lock;
#define RECURSIVE_LOCK_FLAG_CLONE_NAME MUTEX_FLAG_CLONE_NAME
#define RECURSIVE_LOCK_INITIALIZER(name) { MUTEX_INITIALIZER(name), -1, 0 }
#define recursive_lock_init(lock, name) __recursive_lock_init(lock, name)
#define recursive_lock_init_etc(lock, name, flags) \
__recursive_lock_init_etc(lock, name, flags)
#define recursive_lock_destroy(lock) __recursive_lock_destroy(lock)
#define recursive_lock_lock(lock) __recursive_lock_lock(lock)
#define recursive_lock_unlock(lock) __recursive_lock_unlock(lock)
#define recursive_lock_get_recursion(lock) __recursive_lock_get_recursion(lock)
void __recursive_lock_init(recursive_lock *lock, const char *name);
void __recursive_lock_init_etc(recursive_lock *lock, const char *name,
uint32 flags);
void __recursive_lock_destroy(recursive_lock *lock);
status_t __recursive_lock_lock(recursive_lock *lock);
void __recursive_lock_unlock(recursive_lock *lock);
int32 __recursive_lock_get_recursion(recursive_lock *lock);
#define INIT_ONCE_UNINITIALIZED -1
#define INIT_ONCE_INITIALIZED -4
status_t __init_once(int32* control, status_t (*initRoutine)(void*),
void* data);
#ifdef __cplusplus
}
#include <AutoLocker.h>
class MutexLocking {
public:
inline bool Lock(struct mutex *lock)
{
return mutex_lock(lock) == B_OK;
}
inline void Unlock(struct mutex *lock)
{
mutex_unlock(lock);
}
};
typedef AutoLocker<mutex, MutexLocking> MutexLocker;
class RecursiveLockLocking {
public:
inline bool Lock(recursive_lock *lockable)
{
return recursive_lock_lock(lockable) == B_OK;
}
inline void Unlock(recursive_lock *lockable)
{
recursive_lock_unlock(lockable);
}
};
typedef AutoLocker<recursive_lock, RecursiveLockLocking> RecursiveLocker;
class RWLockReadLocking {
public:
inline bool Lock(struct rw_lock *lock)
{
return rw_lock_read_lock(lock) == B_OK;
}
inline void Unlock(struct rw_lock *lock)
{
rw_lock_read_unlock(lock);
}
};
class RWLockWriteLocking {
public:
inline bool Lock(struct rw_lock *lock)
{
return rw_lock_write_lock(lock) == B_OK;
}
inline void Unlock(struct rw_lock *lock)
{
rw_lock_write_unlock(lock);
}
};
typedef AutoLocker<rw_lock, RWLockReadLocking> ReadLocker;
typedef AutoLocker<rw_lock, RWLockWriteLocking> WriteLocker;
#endif
#endif
