storage/src/SQLiteMutex.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_storage_SQLiteMutex_h_
   8 #define mozilla_storage_SQLiteMutex_h_
   9
  10 #include "mozilla/BlockingResourceBase.h"
  11 #include "sqlite3.h"
  12
  13 namespace mozilla {
  14 namespace storage {
  15
  16 /**
  17  * Wrapper class for sqlite3_mutexes.  To be used whenever we want to use a
  18  * sqlite3_mutex.
  19  *
  20  * @warning Never EVER wrap the same sqlite3_mutex with a different SQLiteMutex.
  21  *          If you do this, you void the deadlock detector's warranty!
  22  */
  23 class SQLiteMutex : private BlockingResourceBase
  24 {
  25 public:
  26   /**
  27    * Constructs a wrapper for a sqlite3_mutex that has deadlock detecting.
  28    *
  29    * @param aName
  30    *        A name which can be used to reference this mutex.
  31    */
  32   explicit SQLiteMutex(const char *aName)
  33   : BlockingResourceBase(aName, eMutex)
  34   , mMutex(nullptr)
  35   {
  36   }
  37
  38   /**
  39    * Sets the mutex that we are wrapping.  We generally do not have access to
  40    * our mutex at class construction, so we have to set it once we get access to
  41    * it.
  42    *
  43    * @param aMutex
  44    *        The sqlite3_mutex that we are going to wrap.
  45    */
  46   void initWithMutex(sqlite3_mutex *aMutex)
  47   {
  48     NS_ASSERTION(aMutex, "You must pass in a valid mutex!");
  49     NS_ASSERTION(!mMutex, "A mutex has already been set for this!");
  50     mMutex = aMutex;
  51   }
  52
  53 #if !defined(DEBUG) || defined(MOZ_NATIVE_SQLITE)
  54   /**
  55    * Acquires the mutex.
  56    */
  57   void lock()
  58   {
  59     sqlite3_mutex_enter(mMutex);
  60   }
  61
  62   /**
  63    * Releases the mutex.
  64    */
  65   void unlock()
  66   {
  67     sqlite3_mutex_leave(mMutex);
  68   }
  69
  70   /**
  71    * Asserts that the current thread owns the mutex.
  72    */
  73   void assertCurrentThreadOwns()
  74   {
  75   }
  76
  77   /**
  78    * Asserts that the current thread does not own the mutex.
  79    */
  80   void assertNotCurrentThreadOwns()
  81   {
  82   }
  83
  84 #else
  85   void lock()
  86   {
  87     NS_ASSERTION(mMutex, "No mutex associated with this wrapper!");
  88
  89     // While SQLite Mutexes may be recursive, in our own code we do not want to
  90     // treat them as such.
  91
  92     CheckAcquire();
  93     sqlite3_mutex_enter(mMutex);
  94     Acquire(); // Call is protected by us holding the mutex.
  95   }
  96
  97   void unlock()
  98   {
  99     NS_ASSERTION(mMutex, "No mutex associated with this wrapper!");
 100
 101     // While SQLite Mutexes may be recursive, in our own code we do not want to
 102     // treat them as such.
 103     Release(); // Call is protected by us holding the mutex.
 104     sqlite3_mutex_leave(mMutex);
 105   }
 106
 107   void assertCurrentThreadOwns()
 108   {
 109     NS_ASSERTION(mMutex, "No mutex associated with this wrapper!");
 110     NS_ASSERTION(sqlite3_mutex_held(mMutex),
 111                  "Mutex is not held, but we expect it to be!");
 112   }
 113
 114   void assertNotCurrentThreadOwns()
 115   {
 116     NS_ASSERTION(mMutex, "No mutex associated with this wrapper!");
 117     NS_ASSERTION(sqlite3_mutex_notheld(mMutex),
 118                  "Mutex is held, but we expect it to not be!");
 119   }
 120 #endif // ifndef DEBUG
 121
 122 private:
 123   sqlite3_mutex *mMutex;
 124 };
 125
 126 /**
 127  * Automatically acquires the mutex when it enters scope, and releases it when
 128  * it leaves scope.
 129  */
 130 class MOZ_STACK_CLASS SQLiteMutexAutoLock
 131 {
 132 public:
 133   explicit SQLiteMutexAutoLock(SQLiteMutex &aMutex)
 134   : mMutex(aMutex)
 135   {
 136     mMutex.lock();
 137   }
 138
 139   ~SQLiteMutexAutoLock()
 140   {
 141     mMutex.unlock();
 142   }
 143
 144 private:
 145   SQLiteMutex &mMutex;
 146 };
 147
 148 /**
 149  * Automatically releases the mutex when it enters scope, and acquires it when
 150  * it leaves scope.
 151  */
 152 class MOZ_STACK_CLASS SQLiteMutexAutoUnlock
 153 {
 154 public:
 155   explicit SQLiteMutexAutoUnlock(SQLiteMutex &aMutex)
 156   : mMutex(aMutex)
 157   {
 158     mMutex.unlock();
 159   }
 160
 161   ~SQLiteMutexAutoUnlock()
 162   {
 163     mMutex.lock();
 164   }
 165
 166 private:
 167   SQLiteMutex &mMutex;
 168 };
 169
 170 } // namespace storage
 171 } // namespace mozilla
 172
 173 #endif // mozilla_storage_SQLiteMutex_h_