AutoLock.h revision 13b82bf0e999d7c0c1a30fd67d5f3db8905c27ae
af062818b47340eef15700d2f0211576ba3506eevboxsync/** @file
af062818b47340eef15700d2f0211576ba3506eevboxsync *
af062818b47340eef15700d2f0211576ba3506eevboxsync * Automatic locks, implementation
af062818b47340eef15700d2f0211576ba3506eevboxsync */
af062818b47340eef15700d2f0211576ba3506eevboxsync
af062818b47340eef15700d2f0211576ba3506eevboxsync/*
af062818b47340eef15700d2f0211576ba3506eevboxsync * Copyright (C) 2006-2009 Sun Microsystems, Inc.
af062818b47340eef15700d2f0211576ba3506eevboxsync *
af062818b47340eef15700d2f0211576ba3506eevboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
af062818b47340eef15700d2f0211576ba3506eevboxsync * available from http://www.virtualbox.org. This file is free software;
af062818b47340eef15700d2f0211576ba3506eevboxsync * you can redistribute it and/or modify it under the terms of the GNU
af062818b47340eef15700d2f0211576ba3506eevboxsync * General Public License (GPL) as published by the Free Software
af062818b47340eef15700d2f0211576ba3506eevboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
af062818b47340eef15700d2f0211576ba3506eevboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
af062818b47340eef15700d2f0211576ba3506eevboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
af062818b47340eef15700d2f0211576ba3506eevboxsync *
af062818b47340eef15700d2f0211576ba3506eevboxsync * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
af062818b47340eef15700d2f0211576ba3506eevboxsync * Clara, CA 95054 USA or visit http://www.sun.com if you need
af062818b47340eef15700d2f0211576ba3506eevboxsync * additional information or have any questions.
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync */
4b9d6701570cb98fd36e209314239d104ec584d3vboxsync
4b9d6701570cb98fd36e209314239d104ec584d3vboxsync#ifndef ____H_AUTOLOCK
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync#define ____H_AUTOLOCK
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync#include <iprt/types.h>
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync// macros for automatic lock validation; these will amount to nothing
589fd26cedb2b4ebbed14f2964cad03cc8ebbca2vboxsync// unless lock validation is enabled for the runtime
af062818b47340eef15700d2f0211576ba3506eevboxsync#if defined(RT_LOCK_STRICT) && defined (DEBUG)
af062818b47340eef15700d2f0211576ba3506eevboxsync#define VBOX_WITH_MAIN_LOCK_VALIDATION
af062818b47340eef15700d2f0211576ba3506eevboxsync# define COMMA_LOCKVAL_SRC_POS , RT_SRC_POS
af062818b47340eef15700d2f0211576ba3506eevboxsync# define LOCKVAL_SRC_POS_DECL RT_SRC_POS_DECL
af062818b47340eef15700d2f0211576ba3506eevboxsync# define COMMA_LOCKVAL_SRC_POS_DECL , RT_SRC_POS_DECL
af062818b47340eef15700d2f0211576ba3506eevboxsync# define LOCKVAL_SRC_POS_ARGS RT_SRC_POS_ARGS
af062818b47340eef15700d2f0211576ba3506eevboxsync# define COMMA_LOCKVAL_SRC_POS_ARGS , RT_SRC_POS_ARGS
af062818b47340eef15700d2f0211576ba3506eevboxsync#else
af062818b47340eef15700d2f0211576ba3506eevboxsync# define COMMA_LOCKVAL_SRC_POS
af062818b47340eef15700d2f0211576ba3506eevboxsync# define LOCKVAL_SRC_POS_DECL
af062818b47340eef15700d2f0211576ba3506eevboxsync# define COMMA_LOCKVAL_SRC_POS_DECL
af062818b47340eef15700d2f0211576ba3506eevboxsync# define LOCKVAL_SRC_POS_ARGS
af062818b47340eef15700d2f0211576ba3506eevboxsync# define COMMA_LOCKVAL_SRC_POS_ARGS
af062818b47340eef15700d2f0211576ba3506eevboxsync#endif
af062818b47340eef15700d2f0211576ba3506eevboxsync
af062818b47340eef15700d2f0211576ba3506eevboxsyncnamespace util
af062818b47340eef15700d2f0211576ba3506eevboxsync{
af062818b47340eef15700d2f0211576ba3506eevboxsync
af062818b47340eef15700d2f0211576ba3506eevboxsync////////////////////////////////////////////////////////////////////////////////
af062818b47340eef15700d2f0211576ba3506eevboxsync//
af062818b47340eef15700d2f0211576ba3506eevboxsync// Order classes for lock validation
af062818b47340eef15700d2f0211576ba3506eevboxsync//
af062818b47340eef15700d2f0211576ba3506eevboxsync////////////////////////////////////////////////////////////////////////////////
af062818b47340eef15700d2f0211576ba3506eevboxsync
af062818b47340eef15700d2f0211576ba3506eevboxsync/**
af062818b47340eef15700d2f0211576ba3506eevboxsync * IPRT now has a sophisticated system of run-time locking classes to validate
af062818b47340eef15700d2f0211576ba3506eevboxsync * locking order. Since the Main code is handled by simpler minds, we want
af062818b47340eef15700d2f0211576ba3506eevboxsync * compile-time constants for simplicity, and we'll look up the run-time classes
af062818b47340eef15700d2f0211576ba3506eevboxsync * in AutoLock.cpp transparently. These are passed to the constructors of the
af062818b47340eef15700d2f0211576ba3506eevboxsync * LockHandle classes.
af062818b47340eef15700d2f0211576ba3506eevboxsync */
af062818b47340eef15700d2f0211576ba3506eevboxsyncenum VBoxLockingClass
af062818b47340eef15700d2f0211576ba3506eevboxsync{
af062818b47340eef15700d2f0211576ba3506eevboxsync LOCKCLASS_NONE = 0,
af062818b47340eef15700d2f0211576ba3506eevboxsync LOCKCLASS_VIRTUALBOXOBJECT = 1, // highest order: VirtualBox object lock
af062818b47340eef15700d2f0211576ba3506eevboxsync LOCKCLASS_USBPROXYSERVICE = 2, // USB proxy service object lock
af062818b47340eef15700d2f0211576ba3506eevboxsync LOCKCLASS_HOSTOBJECT = 3, // Host object lock
af062818b47340eef15700d2f0211576ba3506eevboxsync LOCKCLASS_LISTOFMACHINES = 4, // list of machines in VirtualBox object
af062818b47340eef15700d2f0211576ba3506eevboxsync LOCKCLASS_MACHINEOBJECT = 5, // Machine object lock
af062818b47340eef15700d2f0211576ba3506eevboxsync LOCKCLASS_LISTOFSNAPSHOTS = 6, // list of snapshots in Machine object
af062818b47340eef15700d2f0211576ba3506eevboxsync LOCKCLASS_SNAPSHOTOBJECT = 7, // snapshot object locks (need to have lower order
af062818b47340eef15700d2f0211576ba3506eevboxsync // than both MACHINEOBJECT and LOCKCLASS_MACHINELIST since
af062818b47340eef15700d2f0211576ba3506eevboxsync // the list of snapshots in Machine is LOCKCLASS_MACHINELIST)
af062818b47340eef15700d2f0211576ba3506eevboxsync LOCKCLASS_LISTOFMEDIA = 8, // list of media (hard disks, DVDs, floppies) in VirtualBox object
af062818b47340eef15700d2f0211576ba3506eevboxsync LOCKCLASS_LISTOFOTHEROBJECTS = 9, // any other list of objects
af062818b47340eef15700d2f0211576ba3506eevboxsync LOCKCLASS_OTHEROBJECT = 10, // any regular object member variable lock
af062818b47340eef15700d2f0211576ba3506eevboxsync LOCKCLASS_USBLIST = 11, // temporary hack to avoid having to clean up the USB filters
af062818b47340eef15700d2f0211576ba3506eevboxsync // too much @todo r=dj get rid of this!
af062818b47340eef15700d2f0211576ba3506eevboxsync LOCKCLASS_PROGRESSLIST = 12, // list of progress objects in VirtualBox; no other object lock
af062818b47340eef15700d2f0211576ba3506eevboxsync // may be held after this!
af062818b47340eef15700d2f0211576ba3506eevboxsync LOCKCLASS_OBJECTSTATE = 13 // object state lock (handled by AutoCaller classes)
af062818b47340eef15700d2f0211576ba3506eevboxsync};
af062818b47340eef15700d2f0211576ba3506eevboxsync
af062818b47340eef15700d2f0211576ba3506eevboxsyncvoid InitAutoLockSystem();
af062818b47340eef15700d2f0211576ba3506eevboxsync
af062818b47340eef15700d2f0211576ba3506eevboxsync////////////////////////////////////////////////////////////////////////////////
af062818b47340eef15700d2f0211576ba3506eevboxsync//
af062818b47340eef15700d2f0211576ba3506eevboxsync// LockHandle and friends
af062818b47340eef15700d2f0211576ba3506eevboxsync//
af062818b47340eef15700d2f0211576ba3506eevboxsync////////////////////////////////////////////////////////////////////////////////
af062818b47340eef15700d2f0211576ba3506eevboxsync
af062818b47340eef15700d2f0211576ba3506eevboxsync/**
af062818b47340eef15700d2f0211576ba3506eevboxsync * Abstract base class for semaphore handles (RWLockHandle and WriteLockHandle).
af062818b47340eef15700d2f0211576ba3506eevboxsync * Don't use this directly, but this implements lock validation for them.
af062818b47340eef15700d2f0211576ba3506eevboxsync */
af062818b47340eef15700d2f0211576ba3506eevboxsyncclass LockHandle
af062818b47340eef15700d2f0211576ba3506eevboxsync{
af062818b47340eef15700d2f0211576ba3506eevboxsyncpublic:
af062818b47340eef15700d2f0211576ba3506eevboxsync LockHandle()
af062818b47340eef15700d2f0211576ba3506eevboxsync {}
af062818b47340eef15700d2f0211576ba3506eevboxsync
af062818b47340eef15700d2f0211576ba3506eevboxsync virtual ~LockHandle()
af062818b47340eef15700d2f0211576ba3506eevboxsync {}
af062818b47340eef15700d2f0211576ba3506eevboxsync
af062818b47340eef15700d2f0211576ba3506eevboxsync /**
af062818b47340eef15700d2f0211576ba3506eevboxsync * Returns @c true if the current thread holds a write lock on this
af062818b47340eef15700d2f0211576ba3506eevboxsync * read/write semaphore. Intended for debugging only.
af062818b47340eef15700d2f0211576ba3506eevboxsync */
af062818b47340eef15700d2f0211576ba3506eevboxsync virtual bool isWriteLockOnCurrentThread() const = 0;
af062818b47340eef15700d2f0211576ba3506eevboxsync
af062818b47340eef15700d2f0211576ba3506eevboxsync /**
af062818b47340eef15700d2f0211576ba3506eevboxsync * Returns the current write lock level of this semaphore. The lock level
af062818b47340eef15700d2f0211576ba3506eevboxsync * determines the number of nested #lock() calls on the given semaphore
af062818b47340eef15700d2f0211576ba3506eevboxsync * handle.
af062818b47340eef15700d2f0211576ba3506eevboxsync *
af062818b47340eef15700d2f0211576ba3506eevboxsync * Note that this call is valid only when the current thread owns a write
af062818b47340eef15700d2f0211576ba3506eevboxsync * lock on the given semaphore handle and will assert otherwise.
af062818b47340eef15700d2f0211576ba3506eevboxsync */
af062818b47340eef15700d2f0211576ba3506eevboxsync virtual uint32_t writeLockLevel() const = 0;
af062818b47340eef15700d2f0211576ba3506eevboxsync
af062818b47340eef15700d2f0211576ba3506eevboxsync virtual void lockWrite(LOCKVAL_SRC_POS_DECL) = 0;
af062818b47340eef15700d2f0211576ba3506eevboxsync virtual void unlockWrite() = 0;
af062818b47340eef15700d2f0211576ba3506eevboxsync virtual void lockRead(LOCKVAL_SRC_POS_DECL) = 0;
af062818b47340eef15700d2f0211576ba3506eevboxsync virtual void unlockRead() = 0;
af062818b47340eef15700d2f0211576ba3506eevboxsync
af062818b47340eef15700d2f0211576ba3506eevboxsync#ifdef VBOX_WITH_MAIN_LOCK_VALIDATION
af062818b47340eef15700d2f0211576ba3506eevboxsync virtual const char* describe() const = 0;
af062818b47340eef15700d2f0211576ba3506eevboxsync#endif
af062818b47340eef15700d2f0211576ba3506eevboxsync
af062818b47340eef15700d2f0211576ba3506eevboxsyncprivate:
af062818b47340eef15700d2f0211576ba3506eevboxsync // prohibit copy + assignment
af062818b47340eef15700d2f0211576ba3506eevboxsync LockHandle(const LockHandle&);
af062818b47340eef15700d2f0211576ba3506eevboxsync LockHandle& operator=(const LockHandle&);
af062818b47340eef15700d2f0211576ba3506eevboxsync};
af062818b47340eef15700d2f0211576ba3506eevboxsync
af062818b47340eef15700d2f0211576ba3506eevboxsync/**
af062818b47340eef15700d2f0211576ba3506eevboxsync * Full-featured read/write semaphore handle implementation.
af062818b47340eef15700d2f0211576ba3506eevboxsync *
af062818b47340eef15700d2f0211576ba3506eevboxsync * This is an auxiliary base class for classes that need full-featured
af062818b47340eef15700d2f0211576ba3506eevboxsync * read/write locking as described in the AutoWriteLock class documentation.
af062818b47340eef15700d2f0211576ba3506eevboxsync * Instances of classes inherited from this class can be passed as arguments to
af062818b47340eef15700d2f0211576ba3506eevboxsync * the AutoWriteLock and AutoReadLock constructors.
af062818b47340eef15700d2f0211576ba3506eevboxsync */
af062818b47340eef15700d2f0211576ba3506eevboxsyncclass RWLockHandle : public LockHandle
{
public:
RWLockHandle(VBoxLockingClass lockClass);
virtual ~RWLockHandle();
virtual bool isWriteLockOnCurrentThread() const;
virtual void lockWrite(LOCKVAL_SRC_POS_DECL);
virtual void unlockWrite();
virtual void lockRead(LOCKVAL_SRC_POS_DECL);
virtual void unlockRead();
virtual uint32_t writeLockLevel() const;
#ifdef VBOX_WITH_MAIN_LOCK_VALIDATION
virtual const char* describe() const;
#endif
private:
struct Data;
Data *m;
};
/**
* Write-only semaphore handle implementation.
*
* This is an auxiliary base class for classes that need write-only (exclusive)
* locking and do not need read (shared) locking. This implementation uses a
* cheap and fast critical section for both lockWrite() and lockRead() methods
* which makes a lockRead() call fully equivalent to the lockWrite() call and
* therefore makes it pointless to use instahces of this class with
* AutoReadLock instances -- shared locking will not be possible anyway and
* any call to lock() will block if there are lock owners on other threads.
*
* Use with care only when absolutely sure that shared locks are not necessary.
*/
class WriteLockHandle : public LockHandle
{
public:
WriteLockHandle(VBoxLockingClass lockClass);
virtual ~WriteLockHandle();
virtual bool isWriteLockOnCurrentThread() const;
virtual void lockWrite(LOCKVAL_SRC_POS_DECL);
virtual void unlockWrite();
virtual void lockRead(LOCKVAL_SRC_POS_DECL);
virtual void unlockRead();
virtual uint32_t writeLockLevel() const;
#ifdef VBOX_WITH_MAIN_LOCK_VALIDATION
virtual const char* describe() const;
#endif
private:
struct Data;
Data *m;
};
////////////////////////////////////////////////////////////////////////////////
//
// Lockable
//
////////////////////////////////////////////////////////////////////////////////
/**
* Lockable interface.
*
* This is an abstract base for classes that need read/write locking. Unlike
* RWLockHandle and other classes that makes the read/write semaphore a part of
* class data, this class allows subclasses to decide which semaphore handle to
* use.
*/
class Lockable
{
public:
/**
* Returns a pointer to a LockHandle used by AutoWriteLock/AutoReadLock
* for locking. Subclasses are allowed to return @c NULL -- in this case,
* the AutoWriteLock/AutoReadLock object constructed using an instance of
* such subclass will simply turn into no-op.
*/
virtual LockHandle *lockHandle() const = 0;
/**
* Equivalent to <tt>#lockHandle()->isWriteLockOnCurrentThread()</tt>.
* Returns @c false if lockHandle() returns @c NULL.
*/
bool isWriteLockOnCurrentThread()
{
LockHandle *h = lockHandle();
return h ? h->isWriteLockOnCurrentThread() : false;
}
};
////////////////////////////////////////////////////////////////////////////////
//
// AutoLockBase
//
////////////////////////////////////////////////////////////////////////////////
/**
* Abstract base class for all autolocks.
*
* This cannot be used directly. Use AutoReadLock or AutoWriteLock or AutoMultiWriteLock2/3
* which directly and indirectly derive from this.
*
* In the implementation, the instance data contains a list of lock handles.
* The class provides some utility functions to help locking and unlocking
* them.
*/
class AutoLockBase
{
protected:
AutoLockBase(uint32_t cHandles
COMMA_LOCKVAL_SRC_POS_DECL);
AutoLockBase(uint32_t cHandles,
LockHandle *pHandle
COMMA_LOCKVAL_SRC_POS_DECL);
virtual ~AutoLockBase();
struct Data;
Data *m;
virtual void callLockImpl(LockHandle &l) = 0;
virtual void callUnlockImpl(LockHandle &l) = 0;
void callLockOnAllHandles();
void callUnlockOnAllHandles();
void cleanup();
public:
void acquire();
void release();
private:
// prohibit copy + assignment
AutoLockBase(const AutoLockBase&);
AutoLockBase& operator=(const AutoLockBase&);
};
////////////////////////////////////////////////////////////////////////////////
//
// AutoReadLock
//
////////////////////////////////////////////////////////////////////////////////
/**
* Automatic read lock. Use this with a RWLockHandle to request a read/write
* semaphore in read mode. You can also use this with a WriteLockHandle but
* that makes little sense since they treat read mode like write mode.
*
* If constructed with a RWLockHandle or an instance of Lockable (which in
* practice means any VirtualBoxBase derivative), it autoamtically requests
* the lock in read mode and releases the read lock in the destructor.
*/
class AutoReadLock : public AutoLockBase
{
public:
/**
* Constructs a null instance that does not manage any read/write
* semaphore.
*
* Note that all method calls on a null instance are no-ops. This allows to
* have the code where lock protection can be selected (or omitted) at
* runtime.
*/
AutoReadLock(LOCKVAL_SRC_POS_DECL)
: AutoLockBase(1,
NULL
COMMA_LOCKVAL_SRC_POS_ARGS)
{ }
/**
* Constructs a new instance that will start managing the given read/write
* semaphore by requesting a read lock.
*/
AutoReadLock(LockHandle *aHandle
COMMA_LOCKVAL_SRC_POS_DECL)
: AutoLockBase(1,
aHandle
COMMA_LOCKVAL_SRC_POS_ARGS)
{
acquire();
}
/**
* Constructs a new instance that will start managing the given read/write
* semaphore by requesting a read lock.
*/
AutoReadLock(LockHandle &aHandle
COMMA_LOCKVAL_SRC_POS_DECL)
: AutoLockBase(1,
&aHandle
COMMA_LOCKVAL_SRC_POS_ARGS)
{
acquire();
}
/**
* Constructs a new instance that will start managing the given read/write
* semaphore by requesting a read lock.
*/
AutoReadLock(const Lockable &aLockable
COMMA_LOCKVAL_SRC_POS_DECL)
: AutoLockBase(1,
aLockable.lockHandle()
COMMA_LOCKVAL_SRC_POS_ARGS)
{
acquire();
}
/**
* Constructs a new instance that will start managing the given read/write
* semaphore by requesting a read lock.
*/
AutoReadLock(const Lockable *aLockable
COMMA_LOCKVAL_SRC_POS_DECL)
: AutoLockBase(1,
aLockable ? aLockable->lockHandle() : NULL
COMMA_LOCKVAL_SRC_POS_ARGS)
{
acquire();
}
virtual ~AutoReadLock();
virtual void callLockImpl(LockHandle &l);
virtual void callUnlockImpl(LockHandle &l);
};
////////////////////////////////////////////////////////////////////////////////
//
// AutoWriteLockBase
//
////////////////////////////////////////////////////////////////////////////////
/**
* Base class for all auto write locks.
*
* This cannot be used directly. Use AutoWriteLock or AutoMultiWriteLock2/3
* which derive from this.
*
* In addition to utility methods for subclasses, this implements the public
* leave/enter/maybeEnter methods, which are common to all
* write locks.
*/
class AutoWriteLockBase : public AutoLockBase
{
protected:
AutoWriteLockBase(uint32_t cHandles
COMMA_LOCKVAL_SRC_POS_DECL)
: AutoLockBase(cHandles
COMMA_LOCKVAL_SRC_POS_ARGS)
{ }
AutoWriteLockBase(uint32_t cHandles,
LockHandle *pHandle
COMMA_LOCKVAL_SRC_POS_DECL)
: AutoLockBase(cHandles,
pHandle
COMMA_LOCKVAL_SRC_POS_ARGS)
{ }
virtual ~AutoWriteLockBase()
{ }
virtual void callLockImpl(LockHandle &l);
virtual void callUnlockImpl(LockHandle &l);
public:
void leave();
void enter();
void maybeEnter();
};
////////////////////////////////////////////////////////////////////////////////
//
// AutoWriteLock
//
////////////////////////////////////////////////////////////////////////////////
/**
* Automatic write lock. Use this with a RWLockHandle to request a read/write
* semaphore in write mode. There can only ever be one writer of a read/write
* semaphore: while the lock is held in write mode, no other writer or reader
* can request the semaphore and will block.
*
* If constructed with a RWLockHandle or an instance of Lockable (which in
* practice means any VirtualBoxBase derivative), it autoamtically requests
* the lock in write mode and releases the write lock in the destructor.
*
* When used with a WriteLockHandle, it requests the semaphore contained therein
* exclusively.
*/
class AutoWriteLock : public AutoWriteLockBase
{
public:
/**
* Constructs a null instance that does not manage any read/write
* semaphore.
*
* Note that all method calls on a null instance are no-ops. This allows to
* have the code where lock protection can be selected (or omitted) at
* runtime.
*/
AutoWriteLock(LOCKVAL_SRC_POS_DECL)
: AutoWriteLockBase(1,
NULL
COMMA_LOCKVAL_SRC_POS_ARGS)
{ }
/**
* Constructs a new instance that will start managing the given read/write
* semaphore by requesting a write lock.
*/
AutoWriteLock(LockHandle *aHandle
COMMA_LOCKVAL_SRC_POS_DECL)
: AutoWriteLockBase(1,
aHandle
COMMA_LOCKVAL_SRC_POS_ARGS)
{
acquire();
}
/**
* Constructs a new instance that will start managing the given read/write
* semaphore by requesting a write lock.
*/
AutoWriteLock(LockHandle &aHandle
COMMA_LOCKVAL_SRC_POS_DECL)
: AutoWriteLockBase(1,
&aHandle
COMMA_LOCKVAL_SRC_POS_ARGS)
{
acquire();
}
/**
* Constructs a new instance that will start managing the given read/write
* semaphore by requesting a write lock.
*/
AutoWriteLock(const Lockable &aLockable
COMMA_LOCKVAL_SRC_POS_DECL)
: AutoWriteLockBase(1,
aLockable.lockHandle()
COMMA_LOCKVAL_SRC_POS_ARGS)
{
acquire();
}
/**
* Constructs a new instance that will start managing the given read/write
* semaphore by requesting a write lock.
*/
AutoWriteLock(const Lockable *aLockable
COMMA_LOCKVAL_SRC_POS_DECL)
: AutoWriteLockBase(1,
aLockable ? aLockable->lockHandle() : NULL
COMMA_LOCKVAL_SRC_POS_ARGS)
{
acquire();
}
/**
* Release all write locks acquired by this instance through the #lock()
* call and destroys the instance.
*
* Note that if there there are nested #lock() calls without the
* corresponding number of #unlock() calls when the destructor is called, it
* will assert. This is because having an unbalanced number of nested locks
* is a program logic error which must be fixed.
*/
virtual ~AutoWriteLock()
{
cleanup();
}
void attach(LockHandle *aHandle);
/** @see attach (LockHandle *) */
void attach(LockHandle &aHandle)
{
attach(&aHandle);
}
/** @see attach (LockHandle *) */
void attach(const Lockable &aLockable)
{
attach(aLockable.lockHandle());
}
/** @see attach (LockHandle *) */
void attach(const Lockable *aLockable)
{
attach(aLockable ? aLockable->lockHandle() : NULL);
}
bool isWriteLockOnCurrentThread() const;
uint32_t writeLockLevel() const;
};
////////////////////////////////////////////////////////////////////////////////
//
// AutoMultiWriteLock*
//
////////////////////////////////////////////////////////////////////////////////
/**
* A multi-write-lock containing two other write locks.
*
*/
class AutoMultiWriteLock2 : public AutoWriteLockBase
{
public:
AutoMultiWriteLock2(Lockable *pl1,
Lockable *pl2
COMMA_LOCKVAL_SRC_POS_DECL);
AutoMultiWriteLock2(LockHandle *pl1,
LockHandle *pl2
COMMA_LOCKVAL_SRC_POS_DECL);
virtual ~AutoMultiWriteLock2()
{
cleanup();
}
};
/**
* A multi-write-lock containing three other write locks.
*
*/
class AutoMultiWriteLock3 : public AutoWriteLockBase
{
public:
AutoMultiWriteLock3(Lockable *pl1,
Lockable *pl2,
Lockable *pl3
COMMA_LOCKVAL_SRC_POS_DECL);
AutoMultiWriteLock3(LockHandle *pl1,
LockHandle *pl2,
LockHandle *pl3
COMMA_LOCKVAL_SRC_POS_DECL);
virtual ~AutoMultiWriteLock3()
{
cleanup();
}
};
} /* namespace util */
#endif // ____H_AUTOLOCK
/* vi: set tabstop=4 shiftwidth=4 expandtab: */