VirtualBox

Changeset 25310 in vbox for trunk/src/VBox/Main/include


Ignore:
Timestamp:
Dec 10, 2009 5:06:44 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
55876
Message:

Main: lock validator, first batch: implement per-thread stack to trace locking (disabled by default, use VBOX_WITH_LOCK_VALIDATOR, but that WILL FAIL presently)

Location:
trunk/src/VBox/Main/include
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/include/AudioAdapterImpl.h

    r24989 r25310  
    9494    HRESULT saveSettings(settings::AudioAdapter &data);
    9595
    96     bool isModified() { AutoWriteLock alock (this); return mData.isBackedUp(); }
    97     bool isReallyModified() { AutoWriteLock alock (this); return mData.hasActualChanges(); }
     96    bool isModified() { AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); return mData.isBackedUp(); }
     97    bool isReallyModified() { AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); return mData.hasActualChanges(); }
    9898    bool rollback();
    9999    void commit();

  • trunk/src/VBox/Main/include/AutoLock.h

    r25289 r25310  
    55
    66/*
    7  * Copyright (C) 2006-2008 Sun Microsystems, Inc.
     7 * Copyright (C) 2006-2009 Sun Microsystems, Inc.
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2525#include <iprt/types.h>
    2626
     27#ifdef DEBUG
     28# ifdef VBOX_WITH_LOCK_VALIDATOR
     29#  define VBOX_WITH_DEBUG_LOCK_VALIDATOR
     30# endif
     31#endif
     32
     33#ifdef VBOX_WITH_DEBUG_LOCK_VALIDATOR
     34# define COMMA_LOCKVAL_SRC_POS , RT_SRC_POS
     35# define LOCKVAL_SRC_POS_DECL RT_SRC_POS_DECL
     36# define COMMA_LOCKVAL_SRC_POS_DECL , RT_SRC_POS_DECL
     37# define LOCKVAL_SRC_POS_ARGS RT_SRC_POS_ARGS
     38# define COMMA_LOCKVAL_SRC_POS_ARGS , RT_SRC_POS_ARGS
     39#else
     40# define COMMA_LOCKVAL_SRC_POS
     41# define LOCKVAL_SRC_POS_DECL
     42# define COMMA_LOCKVAL_SRC_POS_DECL
     43# define LOCKVAL_SRC_POS_ARGS
     44# define COMMA_LOCKVAL_SRC_POS_ARGS
     45#endif
     46
    2747namespace util
    2848{
    … …  
    3555
    3656/**
    37  * Abstract read/write semaphore handle.
    38  *
    39  * This is a base class to implement semaphores that provide read/write locking.
    40  * Subclasses must implement all pure virtual methods of this class together
    41  * with pure methods of ReadLockOps and WriteLockOps classes.
    42  *
    43  * See the AutoWriteLock class documentation for the detailed description of
    44  * read and write locks.
     57 * Abstract base class for semaphore handles (RWLockHandle and WriteLockHandle).
    4558 */
    4659class LockHandle
    … …  
    6679    virtual uint32_t writeLockLevel() const = 0;
    6780
    68     virtual void lockWrite() = 0;
     81#ifdef VBOX_WITH_DEBUG_LOCK_VALIDATOR
     82    void validateLock(LOCKVAL_SRC_POS_DECL);
     83    void validateUnlock();
     84#endif
     85
     86    virtual void lockWrite(LOCKVAL_SRC_POS_DECL) = 0;
    6987    virtual void unlockWrite() = 0;
    70     virtual void lockRead() = 0;
     88    virtual void lockRead(LOCKVAL_SRC_POS_DECL) = 0;
    7189    virtual void unlockRead() = 0;
     90
     91    static RTTLS s_lockingStackTlsIndex;
    7292
    7393private:
    … …  
    93113    virtual bool isWriteLockOnCurrentThread() const;
    94114
    95     virtual void lockWrite();
     115    virtual void lockWrite(LOCKVAL_SRC_POS_DECL);
    96116    virtual void unlockWrite();
    97     virtual void lockRead();
     117    virtual void lockRead(LOCKVAL_SRC_POS_DECL);
    98118    virtual void unlockRead();
    99119
    … …  
    125145    virtual bool isWriteLockOnCurrentThread() const;
    126146
    127     virtual void lockWrite();
     147    virtual void lockWrite(LOCKVAL_SRC_POS_DECL);
    128148    virtual void unlockWrite();
    129     virtual void lockRead();
     149    virtual void lockRead(LOCKVAL_SRC_POS_DECL);
    130150    virtual void unlockRead();
    131151    virtual uint32_t writeLockLevel() const;
    … …  
    193213{
    194214protected:
    195     AutoLockBase(uint32_t cHandles);
    196     AutoLockBase(uint32_t cHandles, LockHandle *pHandle);
     215    AutoLockBase(uint32_t cHandles
     216                 COMMA_LOCKVAL_SRC_POS_DECL);
     217    AutoLockBase(uint32_t cHandles,
     218                 LockHandle *pHandle
     219                 COMMA_LOCKVAL_SRC_POS_DECL);
    197220    virtual ~AutoLockBase();
    198221
    … …  
    245268     * runtime.
    246269     */
    247     AutoReadLock()
    248         : AutoLockBase(1, NULL)
     270    AutoReadLock(LOCKVAL_SRC_POS_DECL)
     271        : AutoLockBase(1,
     272                       NULL
     273                       COMMA_LOCKVAL_SRC_POS_ARGS)
    249274    { }
    250275
    … …  
    253278     * semaphore by requesting a read lock.
    254279     */
    255     AutoReadLock(LockHandle *aHandle)
    256         : AutoLockBase(1, aHandle)
     280    AutoReadLock(LockHandle *aHandle
     281                 COMMA_LOCKVAL_SRC_POS_DECL)
     282        : AutoLockBase(1,
     283                       aHandle
     284                       COMMA_LOCKVAL_SRC_POS_ARGS)
    257285    {
    258286        acquire();
    … …  
    263291     * semaphore by requesting a read lock.
    264292     */
    265     AutoReadLock(LockHandle &aHandle)
    266         : AutoLockBase(1, &aHandle)
     293    AutoReadLock(LockHandle &aHandle
     294                 COMMA_LOCKVAL_SRC_POS_DECL)
     295        : AutoLockBase(1,
     296                       &aHandle
     297                       COMMA_LOCKVAL_SRC_POS_ARGS)
    267298    {
    268299        acquire();
    … …  
    273304     * semaphore by requesting a read lock.
    274305     */
    275     AutoReadLock(const Lockable &aLockable)
    276         : AutoLockBase(1, aLockable.lockHandle())
     306    AutoReadLock(const Lockable &aLockable
     307                 COMMA_LOCKVAL_SRC_POS_DECL)
     308        : AutoLockBase(1,
     309                       aLockable.lockHandle()
     310                       COMMA_LOCKVAL_SRC_POS_ARGS)
    277311    {
    278312        acquire();
    … …  
    283317     * semaphore by requesting a read lock.
    284318     */
    285     AutoReadLock(const Lockable *aLockable)
    286         : AutoLockBase(1, aLockable ? aLockable->lockHandle() : NULL)
     319    AutoReadLock(const Lockable *aLockable
     320                 COMMA_LOCKVAL_SRC_POS_DECL)
     321        : AutoLockBase(1,
     322                       aLockable ? aLockable->lockHandle() : NULL
     323                       COMMA_LOCKVAL_SRC_POS_ARGS)
    287324    {
    288325        acquire();
    … …  
    314351{
    315352protected:
    316     AutoWriteLockBase(uint32_t cHandles)
    317         : AutoLockBase(cHandles)
     353    AutoWriteLockBase(uint32_t cHandles
     354                      COMMA_LOCKVAL_SRC_POS_DECL)
     355        : AutoLockBase(cHandles
     356                       COMMA_LOCKVAL_SRC_POS_ARGS)
    318357    { }
    319358
    320     AutoWriteLockBase(uint32_t cHandles, LockHandle *pHandle)
    321         : AutoLockBase(cHandles, pHandle)
     359    AutoWriteLockBase(uint32_t cHandles,
     360                      LockHandle *pHandle
     361                      COMMA_LOCKVAL_SRC_POS_DECL)
     362        : AutoLockBase(cHandles,
     363                       pHandle
     364                       COMMA_LOCKVAL_SRC_POS_ARGS)
    322365    { }
    323366
    … …  
    366409     * runtime.
    367410     */
    368     AutoWriteLock()
    369         : AutoWriteLockBase(1, NULL)
     411    AutoWriteLock(LOCKVAL_SRC_POS_DECL)
     412        : AutoWriteLockBase(1,
     413                            NULL
     414                            COMMA_LOCKVAL_SRC_POS_ARGS)
    370415    { }
    371416
    … …  
    374419     * semaphore by requesting a write lock.
    375420     */
    376     AutoWriteLock(LockHandle *aHandle)
    377         : AutoWriteLockBase(1, aHandle)
     421    AutoWriteLock(LockHandle *aHandle
     422                  COMMA_LOCKVAL_SRC_POS_DECL)
     423        : AutoWriteLockBase(1,
     424                            aHandle
     425                            COMMA_LOCKVAL_SRC_POS_ARGS)
    378426    {
    379427        acquire();
    … …  
    384432     * semaphore by requesting a write lock.
    385433     */
    386     AutoWriteLock(LockHandle &aHandle)
    387         : AutoWriteLockBase(1, &aHandle)
     434    AutoWriteLock(LockHandle &aHandle
     435                  COMMA_LOCKVAL_SRC_POS_DECL)
     436        : AutoWriteLockBase(1,
     437                            &aHandle
     438                            COMMA_LOCKVAL_SRC_POS_ARGS)
    388439    {
    389440        acquire();
    … …  
    394445     * semaphore by requesting a write lock.
    395446     */
    396     AutoWriteLock(const Lockable &aLockable)
    397         : AutoWriteLockBase(1, aLockable.lockHandle())
     447    AutoWriteLock(const Lockable &aLockable
     448                  COMMA_LOCKVAL_SRC_POS_DECL)
     449        : AutoWriteLockBase(1,
     450                            aLockable.lockHandle()
     451                            COMMA_LOCKVAL_SRC_POS_ARGS)
    398452    {
    399453        acquire();
    … …  
    404458     * semaphore by requesting a write lock.
    405459     */
    406     AutoWriteLock(const Lockable *aLockable)
    407         : AutoWriteLockBase(1, aLockable ? aLockable->lockHandle() : NULL)
     460    AutoWriteLock(const Lockable *aLockable
     461                  COMMA_LOCKVAL_SRC_POS_DECL)
     462        : AutoWriteLockBase(1,
     463                            aLockable ? aLockable->lockHandle() : NULL
     464                            COMMA_LOCKVAL_SRC_POS_ARGS)
    408465    {
    409466        acquire();
    … …  
    461518{
    462519public:
    463     AutoMultiWriteLock2(Lockable *pl1, Lockable *pl2);
    464     AutoMultiWriteLock2(LockHandle *pl1, LockHandle *pl2);
     520    AutoMultiWriteLock2(Lockable *pl1,
     521                        Lockable *pl2
     522                        COMMA_LOCKVAL_SRC_POS_DECL);
     523    AutoMultiWriteLock2(LockHandle *pl1,
     524                        LockHandle *pl2
     525                        COMMA_LOCKVAL_SRC_POS_DECL);
    465526
    466527    virtual ~AutoMultiWriteLock2()
    … …  
    477538{
    478539public:
    479     AutoMultiWriteLock3(Lockable *pl1, Lockable *pl2, Lockable *pl3);
    480     AutoMultiWriteLock3(LockHandle *pl1, LockHandle *pl2, LockHandle *pl3);
     540    AutoMultiWriteLock3(Lockable *pl1,
     541                        Lockable *pl2,
     542                        Lockable *pl3
     543                        COMMA_LOCKVAL_SRC_POS_DECL);
     544    AutoMultiWriteLock3(LockHandle *pl1,
     545                        LockHandle *pl2,
     546                        LockHandle *pl3
     547                        COMMA_LOCKVAL_SRC_POS_DECL);
    481548
    482549    virtual ~AutoMultiWriteLock3()

  • trunk/src/VBox/Main/include/MachineImpl.h

    r25150 r25310  
    761761                            bool aSetError = false)
    762762    {
    763         AutoWriteLock alock(this);
     763        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    764764        return findSharedFolder(aName, aSharedFolder, aSetError);
    765765    }

  • trunk/src/VBox/Main/include/NetworkAdapterImpl.h

    r25098 r25310  
    140140    HRESULT saveSettings(settings::NetworkAdapter &data);
    141141
    142     bool isModified() { AutoWriteLock alock (this); return mData.isBackedUp(); }
    143     bool isReallyModified() { AutoWriteLock alock (this); return mData.hasActualChanges(); }
     142    bool isModified() { AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); return mData.isBackedUp(); }
     143    bool isReallyModified() { AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); return mData.hasActualChanges(); }
    144144    bool rollback();
    145145    void commit();

  • trunk/src/VBox/Main/include/Shareable.h

    r14949 r25310  
    106106 *      {
    107107 *          // acquire the lock until the end of the block
    108  *          AutoWriteLock alock (mData);
     108 *          AutoWriteLock alock(mData COMMA_LOCKVAL_SRC_POS);
    109109 *          // share with another instance (thatData defined somewhere else)
    110110 *          {
    111  *              AutoReadLock thatLock (thatData);
     111 *              AutoReadLock thatLock(thatData COMMA_LOCKVAL_SRC_POS);
    112112 *              mData = thatData;
    113113 *          }
    … …  
    130130 *      {
    131131 *          // read-only data access
    132  *          AutoReadLock lock (mData); // protect Shareable members (read-only)
    133  *          AutoReadLock dataLock (mData.data()); // protect Data members (read-only)
     132 *          AutoReadLock lock(mData COMMA_LOCKVAL_SRC_POS); // protect Shareable members (read-only)
     133 *          AutoReadLock dataLock(mData.data() COMMA_LOCKVAL_SRC_POS); // protect Data members (read-only)
    134134 *          if (mData->mSomeVield) ...
    135135 *      }
    … …  
    137137 *      {
    138138 *          // data modification
    139  *          AutoReadLock lock (mData); // protect Shareable members (still read-only)
    140  *          AutoWriteLock dataLock (mData.data()); // protect Data members (exclusive)
     139 *          AutoReadLock lock(mData COMMA_LOCKVAL_SRC_POS); // protect Shareable members (still read-only)
     140 *          AutoWriteLock dataLock(mData.data() COMMA_LOCKVAL_SRC_POS); // protect Data members (exclusive)
    141141 *          mData->mSomeVield = someValue;
    142142 *      }

  • trunk/src/VBox/Main/include/VRDPServerImpl.h

    r24989 r25310  
    113113    HRESULT saveSettings(settings::VRDPSettings &data);
    114114
    115     bool isModified() { AutoWriteLock alock (this); return mData.isBackedUp(); }
    116     bool isReallyModified() { AutoWriteLock alock (this); return mData.hasActualChanges(); }
     115    bool isModified() { AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); return mData.isBackedUp(); }
     116    bool isReallyModified() { AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); return mData.hasActualChanges(); }
    117117    bool rollback();
    118118    void commit();

  • trunk/src/VBox/Main/include/objectslist.h

    r25194 r25310  
    8989    void addChild(MyType p)
    9090    {
    91         AutoWriteLock al(m_lock);
     91        AutoWriteLock al(m_lock COMMA_LOCKVAL_SRC_POS);
    9292        m_ll.push_back(p);
    9393    }
    … …  
    100100    void removeChild(MyType p)
    101101    {
    102         AutoWriteLock al(m_lock);
     102        AutoWriteLock al(m_lock COMMA_LOCKVAL_SRC_POS);
    103103        m_ll.remove(p);
    104104    }
    … …  
    113113    void appendOtherList(ObjectsList<T> &ll)
    114114    {
    115         AutoReadLock alr(ll.getLockHandle());
     115        AutoReadLock alr(ll.getLockHandle() COMMA_LOCKVAL_SRC_POS);
    116116        for (const_iterator it = ll.begin();
    117117             it != ll.end();
    … …  
    128128    void uninitAll()
    129129    {
    130         AutoWriteLock al(m_lock);
     130        AutoWriteLock al(m_lock COMMA_LOCKVAL_SRC_POS);
    131131        for (iterator it = m_ll.begin();
    132132             it != m_ll.end();
    … …  
    145145    size_t size()
    146146    {
    147         AutoReadLock al(m_lock);
     147        AutoReadLock al(m_lock COMMA_LOCKVAL_SRC_POS);
    148148        return m_ll.size();
    149149    }
    … …  
    165165    MyType front()
    166166    {
    167         AutoReadLock al(m_lock);
     167        AutoReadLock al(m_lock COMMA_LOCKVAL_SRC_POS);
    168168        return m_ll.front();
    169169    }
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette