haiku/headers/private/shared/locks.h

/*
 * 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
} // extern "C"


#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);
	}
};


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<mutex, MutexLocking> MutexLocker;
typedef AutoLocker<rw_lock, RWLockReadLocking> ReadLocker;
typedef AutoLocker<rw_lock, RWLockWriteLocking> WriteLocker;

#endif // __cplusplus

#endif // _LOCKS_H_