dom/quota/QuotaManager.h

   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 #ifndef mozilla_dom_quota_quotamanager_h__
   8 #define mozilla_dom_quota_quotamanager_h__
   9
  10 #include "QuotaCommon.h"
  11
  12 #include "mozilla/dom/Nullable.h"
  13 #include "mozilla/dom/ipc/IdType.h"
  14 #include "mozilla/Mutex.h"
  15
  16 #include "nsClassHashtable.h"
  17 #include "nsRefPtrHashtable.h"
  18
  19 #include "Client.h"
  20 #include "PersistenceType.h"
  21
  22 #include "prenv.h"
  23
  24 #define QUOTA_MANAGER_CONTRACTID "@mozilla.org/dom/quota/manager;1"
  25
  26 class mozIStorageConnection;
  27 class nsIEventTarget;
  28 class nsIPrincipal;
  29 class nsIThread;
  30 class nsITimer;
  31 class nsIURI;
  32 class nsPIDOMWindowOuter;
  33 class nsIRunnable;
  34
  35 namespace mozilla {
  36
  37 class OriginAttributes;
  38
  39 }  // namespace mozilla
  40
  41 BEGIN_QUOTA_NAMESPACE
  42
  43 class DirectoryLockImpl;
  44 class GroupInfo;
  45 class GroupInfoPair;
  46 class OriginInfo;
  47 class OriginScope;
  48 class QuotaObject;
  49
  50 class NS_NO_VTABLE RefCountedObject {
  51  public:
  52   NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING
  53 };
  54
  55 class DirectoryLock : public RefCountedObject {
  56   friend class DirectoryLockImpl;
  57
  58  private:
  59   DirectoryLock() {}
  60
  61   ~DirectoryLock() {}
  62 };
  63
  64 class NS_NO_VTABLE OpenDirectoryListener : public RefCountedObject {
  65  public:
  66   virtual void DirectoryLockAcquired(DirectoryLock* aLock) = 0;
  67
  68   virtual void DirectoryLockFailed() = 0;
  69
  70  protected:
  71   virtual ~OpenDirectoryListener() {}
  72 };
  73
  74 struct OriginParams {
  75   OriginParams(PersistenceType aPersistenceType, const nsACString& aOrigin)
  76       : mOrigin(aOrigin), mPersistenceType(aPersistenceType) {}
  77
  78   nsCString mOrigin;
  79   PersistenceType mPersistenceType;
  80 };
  81
  82 class QuotaManager final : public BackgroundThreadObject {
  83   friend class DirectoryLockImpl;
  84   friend class GroupInfo;
  85   friend class OriginInfo;
  86   friend class QuotaObject;
  87
  88   typedef nsClassHashtable<nsCStringHashKey, nsTArray<DirectoryLockImpl*>>
  89       DirectoryLockTable;
  90
  91  public:
  92   class CreateRunnable;
  93
  94  private:
  95   class ShutdownRunnable;
  96   class ShutdownObserver;
  97
  98  public:
  99   NS_INLINE_DECL_REFCOUNTING(QuotaManager)
 100
 101   static bool IsRunningXPCShellTests() {
 102     static bool kRunningXPCShellTests =
 103         !!PR_GetEnv("XPCSHELL_TEST_PROFILE_DIR");
 104     return kRunningXPCShellTests;
 105   }
 106
 107   static bool IsRunningGTests() {
 108     static bool kRunningGTests = !!PR_GetEnv("MOZ_RUN_GTEST");
 109     return kRunningGTests;
 110   }
 111
 112   static const char kReplaceChars[];
 113
 114   static void GetOrCreate(nsIRunnable* aCallback,
 115                           nsIEventTarget* aMainEventTarget = nullptr);
 116
 117   // Returns a non-owning reference.
 118   static QuotaManager* Get();
 119
 120   // Returns true if we've begun the shutdown process.
 121   static bool IsShuttingDown();
 122
 123   static bool IsOSMetadata(const nsAString& aFileName);
 124
 125   static bool IsDotFile(const nsAString& aFileName);
 126
 127   bool IsOriginInitialized(const nsACString& aOrigin) const {
 128     AssertIsOnIOThread();
 129
 130     return mInitializedOrigins.Contains(aOrigin);
 131   }
 132
 133   bool IsTemporaryStorageInitialized() const {
 134     AssertIsOnIOThread();
 135
 136     return mTemporaryStorageInitialized;
 137   }
 138
 139   void InitQuotaForOrigin(PersistenceType aPersistenceType,
 140                           const nsACString& aGroup, const nsACString& aOrigin,
 141                           uint64_t aUsageBytes, int64_t aAccessTime,
 142                           bool aPersisted);
 143
 144   void DecreaseUsageForOrigin(PersistenceType aPersistenceType,
 145                               const nsACString& aGroup,
 146                               const nsACString& aOrigin, int64_t aSize);
 147
 148   void UpdateOriginAccessTime(PersistenceType aPersistenceType,
 149                               const nsACString& aGroup,
 150                               const nsACString& aOrigin);
 151
 152   void RemoveQuota();
 153
 154   void RemoveQuotaForOrigin(PersistenceType aPersistenceType,
 155                             const nsACString& aGroup,
 156                             const nsACString& aOrigin) {
 157     MutexAutoLock lock(mQuotaMutex);
 158     LockedRemoveQuotaForOrigin(aPersistenceType, aGroup, aOrigin);
 159   }
 160
 161   already_AddRefed<QuotaObject> GetQuotaObject(PersistenceType aPersistenceType,
 162                                                const nsACString& aGroup,
 163                                                const nsACString& aOrigin,
 164                                                nsIFile* aFile,
 165                                                int64_t aFileSize = -1,
 166                                                int64_t* aFileSizeOut = nullptr);
 167
 168   already_AddRefed<QuotaObject> GetQuotaObject(PersistenceType aPersistenceType,
 169                                                const nsACString& aGroup,
 170                                                const nsACString& aOrigin,
 171                                                const nsAString& aPath,
 172                                                int64_t aFileSize = -1,
 173                                                int64_t* aFileSizeOut = nullptr);
 174
 175   Nullable<bool> OriginPersisted(const nsACString& aGroup,
 176                                  const nsACString& aOrigin);
 177
 178   void PersistOrigin(const nsACString& aGroup, const nsACString& aOrigin);
 179
 180   // Called when a process is being shot down. Aborts any running operations
 181   // for the given process.
 182   void AbortOperationsForProcess(ContentParentId aContentParentId);
 183
 184   nsresult GetDirectoryForOrigin(PersistenceType aPersistenceType,
 185                                  const nsACString& aASCIIOrigin,
 186                                  nsIFile** aDirectory) const;
 187
 188   nsresult RestoreDirectoryMetadata2(nsIFile* aDirectory, bool aPersistent);
 189
 190   nsresult GetDirectoryMetadata2(nsIFile* aDirectory, int64_t* aTimestamp,
 191                                  bool* aPersisted, nsACString& aSuffix,
 192                                  nsACString& aGroup, nsACString& aOrigin);
 193
 194   nsresult GetDirectoryMetadata2WithRestore(
 195       nsIFile* aDirectory, bool aPersistent, int64_t* aTimestamp,
 196       bool* aPersisted, nsACString& aSuffix, nsACString& aGroup,
 197       nsACString& aOrigin, const bool aTelemetry = false);
 198
 199   nsresult GetDirectoryMetadata2(nsIFile* aDirectory, int64_t* aTimestamp,
 200                                  bool* aPersisted);
 201
 202   nsresult GetDirectoryMetadata2WithRestore(nsIFile* aDirectory,
 203                                             bool aPersistent,
 204                                             int64_t* aTimestamp,
 205                                             bool* aPersisted);
 206
 207   // This is the main entry point into the QuotaManager API.
 208   // Any storage API implementation (quota client) that participates in
 209   // centralized quota and storage handling should call this method to get
 210   // a directory lock which will protect client's files from being deleted
 211   // while they are still in use.
 212   // After a lock is acquired, client is notified via the open listener's
 213   // method DirectoryLockAcquired. If the lock couldn't be acquired, client
 214   // gets DirectoryLockFailed notification.
 215   // A lock is a reference counted object and at the time DirectoryLockAcquired
 216   // is called, quota manager holds just one strong reference to it which is
 217   // then immediatelly cleared by quota manager. So it's up to client to add
 218   // a new reference in order to keep the lock alive.
 219   // Unlocking is simply done by dropping all references to the lock object.
 220   // In other words, protection which the lock represents dies with the lock
 221   // object itself.
 222   void OpenDirectory(PersistenceType aPersistenceType, const nsACString& aGroup,
 223                      const nsACString& aOrigin, Client::Type aClientType,
 224                      bool aExclusive, OpenDirectoryListener* aOpenListener);
 225
 226   // XXX RemoveMe once bug 1170279 gets fixed.
 227   void OpenDirectoryInternal(const Nullable<PersistenceType>& aPersistenceType,
 228                              const OriginScope& aOriginScope,
 229                              const Nullable<Client::Type>& aClientType,
 230                              bool aExclusive,
 231                              OpenDirectoryListener* aOpenListener);
 232
 233   // Collect inactive and the least recently used origins.
 234   uint64_t CollectOriginsForEviction(
 235       uint64_t aMinSizeToBeFreed, nsTArray<RefPtr<DirectoryLockImpl>>& aLocks);
 236
 237   void AssertStorageIsInitialized() const
 238 #ifdef DEBUG
 239       ;
 240 #else
 241   {
 242   }
 243 #endif
 244
 245   nsresult EnsureStorageIsInitialized();
 246
 247   nsresult EnsureOriginIsInitialized(PersistenceType aPersistenceType,
 248                                      const nsACString& aSuffix,
 249                                      const nsACString& aGroup,
 250                                      const nsACString& aOrigin,
 251                                      bool aCreateIfNotExists,
 252                                      nsIFile** aDirectory);
 253
 254   nsresult EnsureOriginIsInitializedInternal(
 255       PersistenceType aPersistenceType, const nsACString& aSuffix,
 256       const nsACString& aGroup, const nsACString& aOrigin,
 257       bool aCreateIfNotExists, nsIFile** aDirectory, bool* aCreated);
 258
 259   nsresult EnsureTemporaryStorageIsInitialized();
 260
 261   nsresult EnsureOriginDirectory(nsIFile* aDirectory, bool aCreateIfNotExists,
 262                                  bool* aCreated);
 263
 264   nsresult AboutToClearOrigins(
 265       const Nullable<PersistenceType>& aPersistenceType,
 266       const OriginScope& aOriginScope,
 267       const Nullable<Client::Type>& aClientType);
 268
 269   void OriginClearCompleted(PersistenceType aPersistenceType,
 270                             const nsACString& aOrigin,
 271                             const Nullable<Client::Type>& aClientType);
 272
 273   void ResetOrClearCompleted();
 274
 275   void StartIdleMaintenance() {
 276     AssertIsOnOwningThread();
 277
 278     for (auto& client : mClients) {
 279       client->StartIdleMaintenance();
 280     }
 281   }
 282
 283   void StopIdleMaintenance() {
 284     AssertIsOnOwningThread();
 285
 286     for (auto& client : mClients) {
 287       client->StopIdleMaintenance();
 288     }
 289   }
 290
 291   void AssertCurrentThreadOwnsQuotaMutex() {
 292     mQuotaMutex.AssertCurrentThreadOwns();
 293   }
 294
 295   nsIThread* IOThread() {
 296     NS_ASSERTION(mIOThread, "This should never be null!");
 297     return mIOThread;
 298   }
 299
 300   Client* GetClient(Client::Type aClientType);
 301
 302   const nsString& GetBasePath() const { return mBasePath; }
 303
 304   const nsString& GetStoragePath() const { return mStoragePath; }
 305
 306   const nsString& GetStoragePath(PersistenceType aPersistenceType) const {
 307     if (aPersistenceType == PERSISTENCE_TYPE_PERSISTENT) {
 308       return mPermanentStoragePath;
 309     }
 310
 311     if (aPersistenceType == PERSISTENCE_TYPE_TEMPORARY) {
 312       return mTemporaryStoragePath;
 313     }
 314
 315     MOZ_ASSERT(aPersistenceType == PERSISTENCE_TYPE_DEFAULT);
 316
 317     return mDefaultStoragePath;
 318   }
 319
 320   uint64_t GetGroupLimit() const;
 321
 322   void GetGroupUsageAndLimit(const nsACString& aGroup, UsageInfo* aUsageInfo);
 323
 324   void NotifyStoragePressure(uint64_t aUsage);
 325
 326   static void GetStorageId(PersistenceType aPersistenceType,
 327                            const nsACString& aOrigin, Client::Type aClientType,
 328                            nsACString& aDatabaseId);
 329
 330   static nsresult GetInfoFromPrincipal(nsIPrincipal* aPrincipal,
 331                                        nsACString* aSuffix, nsACString* aGroup,
 332                                        nsACString* aOrigin);
 333
 334   static nsresult GetInfoFromWindow(nsPIDOMWindowOuter* aWindow,
 335                                     nsACString* aSuffix, nsACString* aGroup,
 336                                     nsACString* aOrigin);
 337
 338   static void GetInfoForChrome(nsACString* aSuffix, nsACString* aGroup,
 339                                nsACString* aOrigin);
 340
 341   static bool IsOriginInternal(const nsACString& aOrigin);
 342
 343   static void ChromeOrigin(nsACString& aOrigin);
 344
 345   static bool AreOriginsEqualOnDisk(nsACString& aOrigin1, nsACString& aOrigin2);
 346
 347   static bool ParseOrigin(const nsACString& aOrigin, nsCString& aSpec,
 348                           OriginAttributes* aAttrs);
 349
 350  private:
 351   QuotaManager();
 352
 353   virtual ~QuotaManager();
 354
 355   nsresult Init(const nsAString& aBaseDirPath);
 356
 357   void Shutdown();
 358
 359   already_AddRefed<DirectoryLockImpl> CreateDirectoryLock(
 360       const Nullable<PersistenceType>& aPersistenceType,
 361       const nsACString& aGroup, const OriginScope& aOriginScope,
 362       const Nullable<Client::Type>& aClientType, bool aExclusive,
 363       bool aInternal, OpenDirectoryListener* aOpenListener);
 364
 365   already_AddRefed<DirectoryLockImpl> CreateDirectoryLockForEviction(
 366       PersistenceType aPersistenceType, const nsACString& aGroup,
 367       const nsACString& aOrigin);
 368
 369   void RegisterDirectoryLock(DirectoryLockImpl* aLock);
 370
 371   void UnregisterDirectoryLock(DirectoryLockImpl* aLock);
 372
 373   void RemovePendingDirectoryLock(DirectoryLockImpl* aLock);
 374
 375   uint64_t LockedCollectOriginsForEviction(
 376       uint64_t aMinSizeToBeFreed, nsTArray<RefPtr<DirectoryLockImpl>>& aLocks);
 377
 378   void LockedRemoveQuotaForOrigin(PersistenceType aPersistenceType,
 379                                   const nsACString& aGroup,
 380                                   const nsACString& aOrigin);
 381
 382   already_AddRefed<OriginInfo> LockedGetOriginInfo(
 383       PersistenceType aPersistenceType, const nsACString& aGroup,
 384       const nsACString& aOrigin);
 385
 386   nsresult MaybeUpgradeIndexedDBDirectory();
 387
 388   nsresult MaybeUpgradePersistentStorageDirectory();
 389
 390   nsresult MaybeRemoveOldDirectories();
 391
 392   template <typename Helper>
 393   nsresult UpgradeStorage(const int32_t aOldVersion, const int32_t aNewVersion,
 394                           mozIStorageConnection* aConnection);
 395
 396   nsresult UpgradeStorageFrom0_0To1_0(mozIStorageConnection* aConnection);
 397
 398   nsresult UpgradeStorageFrom1_0To2_0(mozIStorageConnection* aConnection);
 399
 400   nsresult UpgradeStorageFrom2_0To2_1(mozIStorageConnection* aConnection);
 401
 402   nsresult MaybeRemoveLocalStorageData();
 403
 404   nsresult MaybeRemoveLocalStorageDirectories();
 405
 406   nsresult MaybeCreateLocalStorageArchive();
 407
 408   nsresult InitializeRepository(PersistenceType aPersistenceType);
 409
 410   nsresult InitializeOrigin(PersistenceType aPersistenceType,
 411                             const nsACString& aGroup, const nsACString& aOrigin,
 412                             int64_t aAccessTime, bool aPersisted,
 413                             nsIFile* aDirectory);
 414
 415   void CheckTemporaryStorageLimits();
 416
 417   void DeleteFilesForOrigin(PersistenceType aPersistenceType,
 418                             const nsACString& aOrigin);
 419
 420   void FinalizeOriginEviction(nsTArray<RefPtr<DirectoryLockImpl>>& aLocks);
 421
 422   void ReleaseIOThreadObjects() {
 423     AssertIsOnIOThread();
 424
 425     for (uint32_t index = 0; index < uint32_t(Client::TypeMax()); index++) {
 426       mClients[index]->ReleaseIOThreadObjects();
 427     }
 428   }
 429
 430   DirectoryLockTable& GetDirectoryLockTable(PersistenceType aPersistenceType);
 431
 432   bool IsSanitizedOriginValid(const nsACString& aSanitizedOrigin);
 433
 434   static void ShutdownTimerCallback(nsITimer* aTimer, void* aClosure);
 435
 436   mozilla::Mutex mQuotaMutex;
 437
 438   nsClassHashtable<nsCStringHashKey, GroupInfoPair> mGroupInfoPairs;
 439
 440   // Maintains a list of directory locks that are queued.
 441   nsTArray<RefPtr<DirectoryLockImpl>> mPendingDirectoryLocks;
 442
 443   // Maintains a list of directory locks that are acquired or queued.
 444   nsTArray<DirectoryLockImpl*> mDirectoryLocks;
 445
 446   // Directory lock tables that are used to update origin access time.
 447   DirectoryLockTable mTemporaryDirectoryLockTable;
 448   DirectoryLockTable mDefaultDirectoryLockTable;
 449
 450   // Thread on which IO is performed.
 451   nsCOMPtr<nsIThread> mIOThread;
 452
 453   // A timer that gets activated at shutdown to ensure we close all storages.
 454   nsCOMPtr<nsITimer> mShutdownTimer;
 455
 456   // A list of all successfully initialized persistent origins. This list isn't
 457   // protected by any mutex but it is only ever touched on the IO thread.
 458   nsTArray<nsCString> mInitializedOrigins;
 459
 460   // A hash table that is used to cache origin parser results for given
 461   // sanitized origin strings. This hash table isn't protected by any mutex but
 462   // it is only ever touched on the IO thread.
 463   nsDataHashtable<nsCStringHashKey, bool> mValidOrigins;
 464
 465   // This array is populated at initialization time and then never modified, so
 466   // it can be iterated on any thread.
 467   AutoTArray<RefPtr<Client>, Client::TYPE_MAX> mClients;
 468
 469   nsString mBasePath;
 470   nsString mIndexedDBPath;
 471   nsString mStoragePath;
 472   nsString mPermanentStoragePath;
 473   nsString mTemporaryStoragePath;
 474   nsString mDefaultStoragePath;
 475
 476   uint64_t mTemporaryStorageLimit;
 477   uint64_t mTemporaryStorageUsage;
 478   bool mTemporaryStorageInitialized;
 479
 480   bool mStorageInitialized;
 481 };
 482
 483 END_QUOTA_NAMESPACE
 484
 485 #endif /* mozilla_dom_quota_quotamanager_h__ */