dom/quota/CanonicalQuotaObject.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   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 file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "CanonicalQuotaObject.h"
   8
   9 #include "GroupInfo.h"
  10 #include "GroupInfoPair.h"
  11 #include "mozilla/dom/StorageActivityService.h"
  12 #include "mozilla/dom/quota/AssertionsImpl.h"
  13 #include "mozilla/dom/quota/DirectoryLock.h"
  14 #include "mozilla/dom/quota/QuotaManager.h"
  15 #include "mozilla/ipc/BackgroundParent.h"
  16 #include "OriginInfo.h"
  17
  18 namespace mozilla::dom::quota {
  19
  20 NS_IMETHODIMP_(MozExternalRefCountType) CanonicalQuotaObject::AddRef() {
  21   QuotaManager* quotaManager = QuotaManager::Get();
  22   if (!quotaManager) {
  23     NS_ERROR("Null quota manager, this shouldn't happen, possible leak!");
  24
  25     return ++mRefCnt;
  26   }
  27
  28   MutexAutoLock lock(quotaManager->mQuotaMutex);
  29
  30   return ++mRefCnt;
  31 }
  32
  33 NS_IMETHODIMP_(MozExternalRefCountType) CanonicalQuotaObject::Release() {
  34   QuotaManager* quotaManager = QuotaManager::Get();
  35   if (!quotaManager) {
  36     NS_ERROR("Null quota manager, this shouldn't happen, possible leak!");
  37
  38     nsrefcnt count = --mRefCnt;
  39     if (count == 0) {
  40       mRefCnt = 1;
  41       delete this;
  42       return 0;
  43     }
  44
  45     return mRefCnt;
  46   }
  47
  48   {
  49     MutexAutoLock lock(quotaManager->mQuotaMutex);
  50
  51     --mRefCnt;
  52
  53     if (mRefCnt > 0) {
  54       return mRefCnt;
  55     }
  56
  57     if (mOriginInfo) {
  58       mOriginInfo->mCanonicalQuotaObjects.Remove(mPath);
  59     }
  60   }
  61
  62   delete this;
  63   return 0;
  64 }
  65
  66 bool CanonicalQuotaObject::MaybeUpdateSize(int64_t aSize, bool aTruncate) {
  67   QuotaManager* quotaManager = QuotaManager::Get();
  68   MOZ_ASSERT(quotaManager);
  69
  70   MutexAutoLock lock(quotaManager->mQuotaMutex);
  71
  72   return LockedMaybeUpdateSize(aSize, aTruncate);
  73 }
  74
  75 bool CanonicalQuotaObject::IncreaseSize(int64_t aDelta) {
  76   MOZ_ASSERT(aDelta >= 0);
  77
  78   QuotaManager* quotaManager = QuotaManager::Get();
  79   MOZ_ASSERT(quotaManager);
  80
  81   MutexAutoLock lock(quotaManager->mQuotaMutex);
  82
  83   AssertNoOverflow(mSize, aDelta);
  84   int64_t size = mSize + aDelta;
  85
  86   return LockedMaybeUpdateSize(size, /* aTruncate */ false);
  87 }
  88
  89 void CanonicalQuotaObject::DisableQuotaCheck() {
  90   QuotaManager* quotaManager = QuotaManager::Get();
  91   MOZ_ASSERT(quotaManager);
  92
  93   MutexAutoLock lock(quotaManager->mQuotaMutex);
  94
  95   mQuotaCheckDisabled = true;
  96 }
  97
  98 void CanonicalQuotaObject::EnableQuotaCheck() {
  99   QuotaManager* quotaManager = QuotaManager::Get();
 100   MOZ_ASSERT(quotaManager);
 101
 102   MutexAutoLock lock(quotaManager->mQuotaMutex);
 103
 104   mQuotaCheckDisabled = false;
 105 }
 106
 107 bool CanonicalQuotaObject::LockedMaybeUpdateSize(int64_t aSize,
 108                                                  bool aTruncate) {
 109   QuotaManager* quotaManager = QuotaManager::Get();
 110   MOZ_ASSERT(quotaManager);
 111
 112   quotaManager->mQuotaMutex.AssertCurrentThreadOwns();
 113
 114   if (mWritingDone == false && mOriginInfo) {
 115     mWritingDone = true;
 116     StorageActivityService::SendActivity(mOriginInfo->mOrigin);
 117   }
 118
 119   if (mQuotaCheckDisabled) {
 120     return true;
 121   }
 122
 123   if (mSize == aSize) {
 124     return true;
 125   }
 126
 127   if (!mOriginInfo) {
 128     mSize = aSize;
 129     return true;
 130   }
 131
 132   GroupInfo* groupInfo = mOriginInfo->mGroupInfo;
 133   MOZ_ASSERT(groupInfo);
 134
 135   if (mSize > aSize) {
 136     if (aTruncate) {
 137       const int64_t delta = mSize - aSize;
 138
 139       AssertNoUnderflow(quotaManager->mTemporaryStorageUsage, delta);
 140       quotaManager->mTemporaryStorageUsage -= delta;
 141
 142       if (!mOriginInfo->LockedPersisted()) {
 143         AssertNoUnderflow(groupInfo->mUsage, delta);
 144         groupInfo->mUsage -= delta;
 145       }
 146
 147       AssertNoUnderflow(mOriginInfo->mUsage, delta);
 148       mOriginInfo->mUsage -= delta;
 149
 150       MOZ_ASSERT(mOriginInfo->mClientUsages[mClientType].isSome());
 151       AssertNoUnderflow(mOriginInfo->mClientUsages[mClientType].value(), delta);
 152       mOriginInfo->mClientUsages[mClientType] =
 153           Some(mOriginInfo->mClientUsages[mClientType].value() - delta);
 154
 155       mSize = aSize;
 156     }
 157     return true;
 158   }
 159
 160   MOZ_ASSERT(mSize < aSize);
 161
 162   const auto& complementaryPersistenceTypes =
 163       ComplementaryPersistenceTypes(groupInfo->mPersistenceType);
 164
 165   uint64_t delta = aSize - mSize;
 166
 167   AssertNoOverflow(mOriginInfo->mClientUsages[mClientType].valueOr(0), delta);
 168   uint64_t newClientUsage =
 169       mOriginInfo->mClientUsages[mClientType].valueOr(0) + delta;
 170
 171   AssertNoOverflow(mOriginInfo->mUsage, delta);
 172   uint64_t newUsage = mOriginInfo->mUsage + delta;
 173
 174   // Temporary storage has no limit for origin usage (there's a group and the
 175   // global limit though).
 176
 177   uint64_t newGroupUsage = groupInfo->mUsage;
 178   if (!mOriginInfo->LockedPersisted()) {
 179     AssertNoOverflow(groupInfo->mUsage, delta);
 180     newGroupUsage += delta;
 181
 182     uint64_t groupUsage = groupInfo->mUsage;
 183     for (const auto& complementaryPersistenceType :
 184          complementaryPersistenceTypes) {
 185       const auto& complementaryGroupInfo =
 186           groupInfo->mGroupInfoPair->LockedGetGroupInfo(
 187               complementaryPersistenceType);
 188
 189       if (complementaryGroupInfo) {
 190         AssertNoOverflow(groupUsage, complementaryGroupInfo->mUsage);
 191         groupUsage += complementaryGroupInfo->mUsage;
 192       }
 193     }
 194
 195     // Temporary storage has a hard limit for group usage (20 % of the global
 196     // limit).
 197     AssertNoOverflow(groupUsage, delta);
 198     if (groupUsage + delta > quotaManager->GetGroupLimit()) {
 199       return false;
 200     }
 201   }
 202
 203   AssertNoOverflow(quotaManager->mTemporaryStorageUsage, delta);
 204   uint64_t newTemporaryStorageUsage =
 205       quotaManager->mTemporaryStorageUsage + delta;
 206
 207   if (newTemporaryStorageUsage > quotaManager->mTemporaryStorageLimit) {
 208     // This will block the thread without holding the lock while waitting.
 209
 210     AutoTArray<RefPtr<OriginDirectoryLock>, 10> locks;
 211     uint64_t sizeToBeFreed;
 212
 213     if (::mozilla::ipc::IsOnBackgroundThread()) {
 214       MutexAutoUnlock autoUnlock(quotaManager->mQuotaMutex);
 215
 216       sizeToBeFreed = quotaManager->CollectOriginsForEviction(delta, locks);
 217     } else {
 218       sizeToBeFreed =
 219           quotaManager->LockedCollectOriginsForEviction(delta, locks);
 220     }
 221
 222     if (!sizeToBeFreed) {
 223       uint64_t usage = quotaManager->mTemporaryStorageUsage;
 224
 225       MutexAutoUnlock autoUnlock(quotaManager->mQuotaMutex);
 226
 227       quotaManager->NotifyStoragePressure(usage);
 228
 229       return false;
 230     }
 231
 232     NS_ASSERTION(sizeToBeFreed >= delta, "Huh?");
 233
 234     {
 235       MutexAutoUnlock autoUnlock(quotaManager->mQuotaMutex);
 236
 237       for (const auto& lock : locks) {
 238         quotaManager->DeleteOriginDirectory(lock->OriginMetadata());
 239       }
 240     }
 241
 242     // Relocked.
 243
 244     NS_ASSERTION(mOriginInfo, "How come?!");
 245
 246     for (const auto& lock : locks) {
 247       MOZ_ASSERT(!(lock->GetPersistenceType() == groupInfo->mPersistenceType &&
 248                    lock->Origin() == mOriginInfo->mOrigin),
 249                  "Deleted itself!");
 250
 251       quotaManager->LockedRemoveQuotaForOrigin(lock->OriginMetadata());
 252     }
 253
 254     // We unlocked and relocked several times so we need to recompute all the
 255     // essential variables and recheck the group limit.
 256
 257     AssertNoUnderflow(aSize, mSize);
 258     delta = aSize - mSize;
 259
 260     AssertNoOverflow(mOriginInfo->mClientUsages[mClientType].valueOr(0), delta);
 261     newClientUsage = mOriginInfo->mClientUsages[mClientType].valueOr(0) + delta;
 262
 263     AssertNoOverflow(mOriginInfo->mUsage, delta);
 264     newUsage = mOriginInfo->mUsage + delta;
 265
 266     newGroupUsage = groupInfo->mUsage;
 267     if (!mOriginInfo->LockedPersisted()) {
 268       AssertNoOverflow(groupInfo->mUsage, delta);
 269       newGroupUsage += delta;
 270
 271       uint64_t groupUsage = groupInfo->mUsage;
 272
 273       for (const auto& complementaryPersistenceType :
 274            complementaryPersistenceTypes) {
 275         const auto& complementaryGroupInfo =
 276             groupInfo->mGroupInfoPair->LockedGetGroupInfo(
 277                 complementaryPersistenceType);
 278
 279         if (complementaryGroupInfo) {
 280           AssertNoOverflow(groupUsage, complementaryGroupInfo->mUsage);
 281           groupUsage += complementaryGroupInfo->mUsage;
 282         }
 283       }
 284
 285       AssertNoOverflow(groupUsage, delta);
 286       if (groupUsage + delta > quotaManager->GetGroupLimit()) {
 287         // Unfortunately some other thread increased the group usage in the
 288         // meantime and we are not below the group limit anymore.
 289
 290         // However, the origin eviction must be finalized in this case too.
 291         MutexAutoUnlock autoUnlock(quotaManager->mQuotaMutex);
 292
 293         quotaManager->FinalizeOriginEviction(std::move(locks));
 294
 295         return false;
 296       }
 297     }
 298
 299     AssertNoOverflow(quotaManager->mTemporaryStorageUsage, delta);
 300     newTemporaryStorageUsage = quotaManager->mTemporaryStorageUsage + delta;
 301
 302     NS_ASSERTION(
 303         newTemporaryStorageUsage <= quotaManager->mTemporaryStorageLimit,
 304         "How come?!");
 305
 306     // Ok, we successfully freed enough space and the operation can continue
 307     // without throwing the quota error.
 308     mOriginInfo->mClientUsages[mClientType] = Some(newClientUsage);
 309
 310     mOriginInfo->mUsage = newUsage;
 311     if (!mOriginInfo->LockedPersisted()) {
 312       groupInfo->mUsage = newGroupUsage;
 313     }
 314     quotaManager->mTemporaryStorageUsage = newTemporaryStorageUsage;
 315     ;
 316
 317     // Some other thread could increase the size in the meantime, but no more
 318     // than this one.
 319     MOZ_ASSERT(mSize < aSize);
 320     mSize = aSize;
 321
 322     // Finally, release IO thread only objects and allow next synchronized
 323     // ops for the evicted origins.
 324     MutexAutoUnlock autoUnlock(quotaManager->mQuotaMutex);
 325
 326     quotaManager->FinalizeOriginEviction(std::move(locks));
 327
 328     return true;
 329   }
 330
 331   mOriginInfo->mClientUsages[mClientType] = Some(newClientUsage);
 332
 333   mOriginInfo->mUsage = newUsage;
 334   if (!mOriginInfo->LockedPersisted()) {
 335     groupInfo->mUsage = newGroupUsage;
 336   }
 337   quotaManager->mTemporaryStorageUsage = newTemporaryStorageUsage;
 338
 339   mSize = aSize;
 340
 341   return true;
 342 }
 343
 344 }  // namespace mozilla::dom::quota