Ingo Weinhold
bce7e9f695
interrupts) and SpinLocker (acquires/releases spinlocks). * Adjusted Jamfiles of components that used <util/AutoLock.h> but didn't add all header directories required now (<int.h> was added). git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@21873 a95241bf-73f2-0310-859d-f6bbb57e9c96
127 lines
2.2 KiB
C++
127 lines
2.2 KiB
C++
/*
|
|
* Copyright 2005-2007, Ingo Weinhold, [email protected]. All rights reserved.
|
|
* Distributed under the terms of the MIT License.
|
|
*/
|
|
#ifndef KERNEL_UTIL_AUTO_LOCKER_H
|
|
#define KERNEL_UTIL_AUTO_LOCKER_H
|
|
|
|
|
|
#include <KernelExport.h>
|
|
|
|
#include <shared/AutoLocker.h>
|
|
|
|
#include <int.h>
|
|
#include <lock.h>
|
|
|
|
|
|
namespace BPrivate {
|
|
|
|
// MutexLocking
|
|
class MutexLocking {
|
|
public:
|
|
inline bool Lock(mutex *lockable)
|
|
{
|
|
return mutex_lock(lockable) == B_OK;
|
|
}
|
|
|
|
inline void Unlock(mutex *lockable)
|
|
{
|
|
mutex_unlock(lockable);
|
|
}
|
|
};
|
|
|
|
// MutexLocker
|
|
typedef AutoLocker<mutex, MutexLocking> MutexLocker;
|
|
|
|
// RecursiveLockLocking
|
|
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);
|
|
}
|
|
};
|
|
|
|
// RecursiveLocker
|
|
typedef AutoLocker<recursive_lock, RecursiveLockLocking> RecursiveLocker;
|
|
|
|
// BenaphoreLocking
|
|
class BenaphoreLocking {
|
|
public:
|
|
inline bool Lock(benaphore *lockable)
|
|
{
|
|
return benaphore_lock(lockable) == B_OK;
|
|
}
|
|
|
|
inline void Unlock(benaphore *lockable)
|
|
{
|
|
benaphore_unlock(lockable);
|
|
}
|
|
};
|
|
|
|
// BenaphoreLocker
|
|
typedef AutoLocker<benaphore, BenaphoreLocking> BenaphoreLocker;
|
|
|
|
// InterruptsLocking
|
|
class InterruptsLocking {
|
|
public:
|
|
inline bool Lock(int* lockable)
|
|
{
|
|
*lockable = disable_interrupts();
|
|
return true;
|
|
}
|
|
|
|
inline void Unlock(int* lockable)
|
|
{
|
|
restore_interrupts(*lockable);
|
|
}
|
|
};
|
|
|
|
// InterruptsLocker
|
|
class InterruptsLocker : AutoLocker<int, InterruptsLocking> {
|
|
public:
|
|
inline InterruptsLocker(bool alreadyLocked = false,
|
|
bool lockIfNotLocked = true)
|
|
: AutoLocker<int, InterruptsLocking>(&fState, alreadyLocked,
|
|
lockIfNotLocked)
|
|
{
|
|
}
|
|
|
|
private:
|
|
int fState;
|
|
};
|
|
|
|
// SpinLocking
|
|
class SpinLocking {
|
|
public:
|
|
inline bool Lock(spinlock* lockable)
|
|
{
|
|
acquire_spinlock(lockable);
|
|
return true;
|
|
}
|
|
|
|
inline void Unlock(spinlock* lockable)
|
|
{
|
|
release_spinlock(lockable);
|
|
}
|
|
};
|
|
|
|
// SpinLocker
|
|
typedef AutoLocker<spinlock, SpinLocking> SpinLocker;
|
|
|
|
} // namespace BPrivate
|
|
|
|
using BPrivate::AutoLocker;
|
|
using BPrivate::MutexLocker;
|
|
using BPrivate::RecursiveLocker;
|
|
using BPrivate::BenaphoreLocker;
|
|
using BPrivate::InterruptsLocker;
|
|
using BPrivate::SpinLocker;
|
|
|
|
#endif // KERNEL_UTIL_AUTO_LOCKER_H
|