summaryrefslogtreecommitdiffstats
path: root/dom/quota/DirectoryLockImpl.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/quota/DirectoryLockImpl.cpp')
-rw-r--r--dom/quota/DirectoryLockImpl.cpp381
1 files changed, 381 insertions, 0 deletions
diff --git a/dom/quota/DirectoryLockImpl.cpp b/dom/quota/DirectoryLockImpl.cpp
new file mode 100644
index 0000000000..2993971c7a
--- /dev/null
+++ b/dom/quota/DirectoryLockImpl.cpp
@@ -0,0 +1,381 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "DirectoryLockImpl.h"
+
+#include "mozilla/ReverseIterator.h"
+#include "mozilla/dom/quota/Client.h"
+#include "mozilla/dom/quota/QuotaManager.h"
+
+namespace mozilla::dom::quota {
+
+DirectoryLockImpl::DirectoryLockImpl(
+ MovingNotNull<RefPtr<QuotaManager>> aQuotaManager,
+ const Nullable<PersistenceType>& aPersistenceType,
+ const nsACString& aSuffix, const nsACString& aGroup,
+ const OriginScope& aOriginScope, const nsACString& aStorageOrigin,
+ bool aIsPrivate, const Nullable<Client::Type>& aClientType,
+ const bool aExclusive, const bool aInternal,
+ const ShouldUpdateLockIdTableFlag aShouldUpdateLockIdTableFlag)
+ : mQuotaManager(std::move(aQuotaManager)),
+ mPersistenceType(aPersistenceType),
+ mSuffix(aSuffix),
+ mGroup(aGroup),
+ mOriginScope(aOriginScope),
+ mStorageOrigin(aStorageOrigin),
+ mClientType(aClientType),
+ mId(mQuotaManager->GenerateDirectoryLockId()),
+ mIsPrivate(aIsPrivate),
+ mExclusive(aExclusive),
+ mInternal(aInternal),
+ mShouldUpdateLockIdTable(aShouldUpdateLockIdTableFlag ==
+ ShouldUpdateLockIdTableFlag::Yes),
+ mRegistered(false) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT_IF(aOriginScope.IsOrigin(), !aOriginScope.GetOrigin().IsEmpty());
+ MOZ_ASSERT_IF(!aInternal, !aPersistenceType.IsNull());
+ MOZ_ASSERT_IF(!aInternal,
+ aPersistenceType.Value() != PERSISTENCE_TYPE_INVALID);
+ MOZ_ASSERT_IF(!aInternal, !aGroup.IsEmpty());
+ MOZ_ASSERT_IF(!aInternal, aOriginScope.IsOrigin());
+ MOZ_ASSERT_IF(!aInternal, !aStorageOrigin.IsEmpty());
+ MOZ_ASSERT_IF(!aInternal && !aIsPrivate,
+ aOriginScope.GetOrigin() == aStorageOrigin);
+ MOZ_ASSERT_IF(!aInternal && aIsPrivate,
+ aOriginScope.GetOrigin() != aStorageOrigin);
+ MOZ_ASSERT_IF(!aInternal, !aClientType.IsNull());
+ MOZ_ASSERT_IF(!aInternal, aClientType.Value() < Client::TypeMax());
+}
+
+DirectoryLockImpl::~DirectoryLockImpl() {
+ AssertIsOnOwningThread();
+
+ // We must call UnregisterDirectoryLock before unblocking other locks because
+ // UnregisterDirectoryLock also updates the origin last access time and the
+ // access flag (if the last lock for given origin is unregistered). One of the
+ // blocked locks could be requested by the clear/reset operation which stores
+ // cached information about origins in storage.sqlite. So if the access flag
+ // is not updated before unblocking the lock for reset/clear, we might store
+ // invalid information which can lead to omitting origin initialization during
+ // next temporary storage initialization.
+ if (mRegistered) {
+ mQuotaManager->UnregisterDirectoryLock(*this);
+ }
+
+ MOZ_ASSERT(!mRegistered);
+
+ for (NotNull<RefPtr<DirectoryLockImpl>> blockingLock : mBlocking) {
+ blockingLock->MaybeUnblock(*this);
+ }
+
+ mBlocking.Clear();
+}
+
+#ifdef DEBUG
+
+void DirectoryLockImpl::AssertIsOnOwningThread() const {
+ mQuotaManager->AssertIsOnOwningThread();
+}
+
+#endif // DEBUG
+
+bool DirectoryLockImpl::Overlaps(const DirectoryLockImpl& aLock) const {
+ AssertIsOnOwningThread();
+
+ // If the persistence types don't overlap, the op can proceed.
+ if (!aLock.mPersistenceType.IsNull() && !mPersistenceType.IsNull() &&
+ aLock.mPersistenceType.Value() != mPersistenceType.Value()) {
+ return false;
+ }
+
+ // If the origin scopes don't overlap, the op can proceed.
+ bool match = aLock.mOriginScope.Matches(mOriginScope);
+ if (!match) {
+ return false;
+ }
+
+ // If the client types don't overlap, the op can proceed.
+ if (!aLock.mClientType.IsNull() && !mClientType.IsNull() &&
+ aLock.mClientType.Value() != mClientType.Value()) {
+ return false;
+ }
+
+ // Otherwise, when all attributes overlap (persistence type, origin scope and
+ // client type) the op must wait.
+ return true;
+}
+
+bool DirectoryLockImpl::MustWaitFor(const DirectoryLockImpl& aLock) const {
+ AssertIsOnOwningThread();
+
+ // Waiting is never required if the ops in comparison represent shared locks.
+ if (!aLock.mExclusive && !mExclusive) {
+ return false;
+ }
+
+ // Wait if the ops overlap.
+ return Overlaps(aLock);
+}
+
+void DirectoryLockImpl::NotifyOpenListener() {
+ AssertIsOnOwningThread();
+
+ if (mInvalidated) {
+ if (mOpenListener) {
+ (*mOpenListener)->DirectoryLockFailed();
+ } else {
+ mAcquirePromiseHolder.Reject(NS_ERROR_FAILURE, __func__);
+ }
+ } else {
+#ifdef DEBUG
+ mAcquired.Flip();
+#endif
+
+ if (mOpenListener) {
+ (*mOpenListener)
+ ->DirectoryLockAcquired(static_cast<UniversalDirectoryLock*>(this));
+ } else {
+ mAcquirePromiseHolder.Resolve(true, __func__);
+ }
+ }
+
+ if (mOpenListener) {
+ mOpenListener.destroy();
+ } else {
+ MOZ_ASSERT(mAcquirePromiseHolder.IsEmpty());
+ }
+
+ mQuotaManager->RemovePendingDirectoryLock(*this);
+
+ mPending.Flip();
+}
+
+void DirectoryLockImpl::Acquire(RefPtr<OpenDirectoryListener> aOpenListener) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aOpenListener);
+
+ mOpenListener.init(WrapNotNullUnchecked(std::move(aOpenListener)));
+
+ AcquireInternal();
+}
+
+RefPtr<BoolPromise> DirectoryLockImpl::Acquire() {
+ AssertIsOnOwningThread();
+
+ RefPtr<BoolPromise> result = mAcquirePromiseHolder.Ensure(__func__);
+
+ AcquireInternal();
+
+ return result;
+}
+
+void DirectoryLockImpl::AcquireInternal() {
+ AssertIsOnOwningThread();
+
+ mQuotaManager->AddPendingDirectoryLock(*this);
+
+ // See if this lock needs to wait.
+ bool blocked = false;
+
+ // XXX It is probably unnecessary to iterate this in reverse order.
+ for (DirectoryLockImpl* const existingLock :
+ Reversed(mQuotaManager->mDirectoryLocks)) {
+ if (MustWaitFor(*existingLock)) {
+ existingLock->AddBlockingLock(*this);
+ AddBlockedOnLock(*existingLock);
+ blocked = true;
+ }
+ }
+
+ mQuotaManager->RegisterDirectoryLock(*this);
+
+ // Otherwise, notify the open listener immediately.
+ if (!blocked) {
+ NotifyOpenListener();
+ return;
+ }
+
+ if (!mExclusive || !mInternal) {
+ return;
+ }
+
+ // All the locks that block this new exclusive internal lock need to be
+ // invalidated. We also need to notify clients to abort operations for them.
+ QuotaManager::DirectoryLockIdTableArray lockIds;
+ lockIds.SetLength(Client::TypeMax());
+
+ const auto& blockedOnLocks = GetBlockedOnLocks();
+ MOZ_ASSERT(!blockedOnLocks.IsEmpty());
+
+ for (DirectoryLockImpl* blockedOnLock : blockedOnLocks) {
+ if (!blockedOnLock->IsInternal()) {
+ blockedOnLock->Invalidate();
+
+ // Clients don't have to handle pending locks. Invalidation is sufficient
+ // in that case (once a lock is ready and the listener needs to be
+ // notified, we will call DirectoryLockFailed instead of
+ // DirectoryLockAcquired which should release any remaining references to
+ // the lock).
+ if (!blockedOnLock->IsPending()) {
+ lockIds[blockedOnLock->ClientType()].Put(blockedOnLock->Id());
+ }
+ }
+ }
+
+ mQuotaManager->AbortOperationsForLocks(lockIds);
+}
+
+void DirectoryLockImpl::AcquireImmediately() {
+ AssertIsOnOwningThread();
+
+#ifdef DEBUG
+ for (const DirectoryLockImpl* const existingLock :
+ mQuotaManager->mDirectoryLocks) {
+ MOZ_ASSERT(!MustWaitFor(*existingLock));
+ }
+#endif
+
+ mQuotaManager->RegisterDirectoryLock(*this);
+}
+
+#ifdef DEBUG
+void DirectoryLockImpl::AssertIsAcquiredExclusively() {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mBlockedOn.IsEmpty());
+ MOZ_ASSERT(mExclusive);
+ MOZ_ASSERT(mInternal);
+ MOZ_ASSERT(mRegistered);
+ MOZ_ASSERT(!mInvalidated);
+ MOZ_ASSERT(mAcquired);
+
+ bool found = false;
+
+ for (const DirectoryLockImpl* const existingLock :
+ mQuotaManager->mDirectoryLocks) {
+ if (existingLock == this) {
+ MOZ_ASSERT(!found);
+ found = true;
+ } else if (existingLock->mAcquired) {
+ MOZ_ASSERT(false);
+ }
+ }
+
+ MOZ_ASSERT(found);
+}
+#endif
+
+RefPtr<ClientDirectoryLock> DirectoryLockImpl::SpecializeForClient(
+ PersistenceType aPersistenceType,
+ const quota::OriginMetadata& aOriginMetadata,
+ Client::Type aClientType) const {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aPersistenceType != PERSISTENCE_TYPE_INVALID);
+ MOZ_ASSERT(!aOriginMetadata.mGroup.IsEmpty());
+ MOZ_ASSERT(!aOriginMetadata.mOrigin.IsEmpty());
+ MOZ_ASSERT(aClientType < Client::TypeMax());
+ MOZ_ASSERT(!mOpenListener);
+ MOZ_ASSERT(mAcquirePromiseHolder.IsEmpty());
+ MOZ_ASSERT(mBlockedOn.IsEmpty());
+
+ if (NS_WARN_IF(mExclusive)) {
+ return nullptr;
+ }
+
+ RefPtr<DirectoryLockImpl> lock = Create(
+ mQuotaManager, Nullable<PersistenceType>(aPersistenceType),
+ aOriginMetadata.mSuffix, aOriginMetadata.mGroup,
+ OriginScope::FromOrigin(aOriginMetadata.mOrigin),
+ aOriginMetadata.mStorageOrigin, aOriginMetadata.mIsPrivate,
+ Nullable<Client::Type>(aClientType),
+ /* aExclusive */ false, mInternal, ShouldUpdateLockIdTableFlag::Yes);
+ if (NS_WARN_IF(!Overlaps(*lock))) {
+ return nullptr;
+ }
+
+#ifdef DEBUG
+ for (DirectoryLockImpl* const existingLock :
+ Reversed(mQuotaManager->mDirectoryLocks)) {
+ if (existingLock != this && !existingLock->MustWaitFor(*this)) {
+ MOZ_ASSERT(!existingLock->MustWaitFor(*lock));
+ }
+ }
+#endif
+
+ for (const auto& blockedLock : mBlocking) {
+ if (blockedLock->MustWaitFor(*lock)) {
+ lock->AddBlockingLock(*blockedLock);
+ blockedLock->AddBlockedOnLock(*lock);
+ }
+ }
+
+ mQuotaManager->RegisterDirectoryLock(*lock);
+
+ if (mInvalidated) {
+ lock->Invalidate();
+ }
+
+ return lock;
+}
+
+void DirectoryLockImpl::Log() const {
+ AssertIsOnOwningThread();
+
+ if (!QM_LOG_TEST()) {
+ return;
+ }
+
+ QM_LOG(("DirectoryLockImpl [%p]", this));
+
+ nsCString persistenceType;
+ if (mPersistenceType.IsNull()) {
+ persistenceType.AssignLiteral("null");
+ } else {
+ persistenceType.Assign(PersistenceTypeToString(mPersistenceType.Value()));
+ }
+ QM_LOG((" mPersistenceType: %s", persistenceType.get()));
+
+ QM_LOG((" mGroup: %s", mGroup.get()));
+
+ nsCString originScope;
+ if (mOriginScope.IsOrigin()) {
+ originScope.AssignLiteral("origin:");
+ originScope.Append(mOriginScope.GetOrigin());
+ } else if (mOriginScope.IsPrefix()) {
+ originScope.AssignLiteral("prefix:");
+ originScope.Append(mOriginScope.GetOriginNoSuffix());
+ } else if (mOriginScope.IsPattern()) {
+ originScope.AssignLiteral("pattern:");
+ // Can't call GetJSONPattern since it only works on the main thread.
+ } else {
+ MOZ_ASSERT(mOriginScope.IsNull());
+ originScope.AssignLiteral("null");
+ }
+ QM_LOG((" mOriginScope: %s", originScope.get()));
+
+ const auto clientType = mClientType.IsNull()
+ ? nsAutoCString{"null"_ns}
+ : Client::TypeToText(mClientType.Value());
+ QM_LOG((" mClientType: %s", clientType.get()));
+
+ nsCString blockedOnString;
+ for (auto blockedOn : mBlockedOn) {
+ blockedOnString.Append(
+ nsPrintfCString(" [%p]", static_cast<void*>(blockedOn)));
+ }
+ QM_LOG((" mBlockedOn:%s", blockedOnString.get()));
+
+ QM_LOG((" mExclusive: %d", mExclusive));
+
+ QM_LOG((" mInternal: %d", mInternal));
+
+ QM_LOG((" mInvalidated: %d", static_cast<bool>(mInvalidated)));
+
+ for (auto blockedOn : mBlockedOn) {
+ blockedOn->Log();
+ }
+}
+
+} // namespace mozilla::dom::quota