diff options
Diffstat (limited to 'dom/system/gonk/nsVolume.cpp')
| -rw-r--r-- | dom/system/gonk/nsVolume.cpp | 467 |
1 files changed, 467 insertions, 0 deletions
diff --git a/dom/system/gonk/nsVolume.cpp b/dom/system/gonk/nsVolume.cpp new file mode 100644 index 000000000..77a1628e4 --- /dev/null +++ b/dom/system/gonk/nsVolume.cpp @@ -0,0 +1,467 @@ +/* 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 "nsVolume.h" + +#include "base/message_loop.h" +#include "base/task.h" +#include "nsIPowerManagerService.h" +#include "nsISupportsUtils.h" +#include "nsIVolume.h" +#include "nsServiceManagerUtils.h" +#include "nsThreadUtils.h" +#include "nsVolumeStat.h" +#include "nsXULAppAPI.h" +#include "Volume.h" +#include "AutoMounter.h" +#include "VolumeManager.h" + +#undef VOLUME_MANAGER_LOG_TAG +#define VOLUME_MANAGER_LOG_TAG "nsVolume" +#include "VolumeManagerLog.h" + +namespace mozilla { +namespace system { + +const char * +NS_VolumeStateStr(int32_t aState) +{ + switch (aState) { + case nsIVolume::STATE_INIT: return "Init"; + case nsIVolume::STATE_NOMEDIA: return "NoMedia"; + case nsIVolume::STATE_IDLE: return "Idle"; + case nsIVolume::STATE_PENDING: return "Pending"; + case nsIVolume::STATE_CHECKING: return "Checking"; + case nsIVolume::STATE_MOUNTED: return "Mounted"; + case nsIVolume::STATE_UNMOUNTING: return "Unmounting"; + case nsIVolume::STATE_FORMATTING: return "Formatting"; + case nsIVolume::STATE_SHARED: return "Shared"; + case nsIVolume::STATE_SHAREDMNT: return "Shared-Mounted"; + case nsIVolume::STATE_CHECKMNT: return "Check-Mounted"; + case nsIVolume::STATE_MOUNT_FAIL: return "Mount-Fail"; + } + return "???"; +} + +// While nsVolumes can only be used on the main thread, in the +// UpdateVolumeRunnable constructor (which is called from IOThread) we +// allocate an nsVolume which is then passed to MainThread. Since we +// have a situation where we allocate on one thread and free on another +// we use a thread safe AddRef implementation. +NS_IMPL_ISUPPORTS(nsVolume, nsIVolume) + +nsVolume::nsVolume(const Volume* aVolume) + : mName(NS_ConvertUTF8toUTF16(aVolume->Name())), + mMountPoint(NS_ConvertUTF8toUTF16(aVolume->MountPoint())), + mState(aVolume->State()), + mMountGeneration(aVolume->MountGeneration()), + mMountLocked(aVolume->IsMountLocked()), + mIsFake(!aVolume->CanBeShared()), + mIsMediaPresent(aVolume->MediaPresent()), + mIsSharing(aVolume->IsSharing()), + mIsFormatting(aVolume->IsFormatting()), + mIsUnmounting(aVolume->IsUnmounting()), + mIsRemovable(aVolume->IsRemovable()), + mIsHotSwappable(aVolume->IsHotSwappable()) +{ +} + +nsVolume::nsVolume(const nsVolume* aVolume) + : mName(aVolume->mName), + mMountPoint(aVolume->mMountPoint), + mState(aVolume->mState), + mMountGeneration(aVolume->mMountGeneration), + mMountLocked(aVolume->mMountLocked), + mIsFake(aVolume->mIsFake), + mIsMediaPresent(aVolume->mIsMediaPresent), + mIsSharing(aVolume->mIsSharing), + mIsFormatting(aVolume->mIsFormatting), + mIsUnmounting(aVolume->mIsUnmounting), + mIsRemovable(aVolume->mIsRemovable), + mIsHotSwappable(aVolume->mIsHotSwappable) +{ +} + +void nsVolume::Dump(const char* aLabel) const +{ + LOG("%s: Volume: %s is %s and %s @ %s gen %d locked %d", + aLabel, + NameStr().get(), + StateStr(), + IsMediaPresent() ? "inserted" : "missing", + MountPointStr().get(), + MountGeneration(), + (int)IsMountLocked()); + LOG("%s: IsSharing %s IsFormating %s IsUnmounting %s", + aLabel, + (IsSharing() ? "y" : "n"), + (IsFormatting() ? "y" : "n"), + (IsUnmounting() ? "y" : "n")); +} + +bool nsVolume::Equals(nsIVolume* aVolume) +{ + nsString volName; + aVolume->GetName(volName); + if (!mName.Equals(volName)) { + return false; + } + + nsString volMountPoint; + aVolume->GetMountPoint(volMountPoint); + if (!mMountPoint.Equals(volMountPoint)) { + return false; + } + + int32_t volState; + aVolume->GetState(&volState); + if (mState != volState){ + return false; + } + + int32_t volMountGeneration; + aVolume->GetMountGeneration(&volMountGeneration); + if (mMountGeneration != volMountGeneration) { + return false; + } + + bool volIsMountLocked; + aVolume->GetIsMountLocked(&volIsMountLocked); + if (mMountLocked != volIsMountLocked) { + return false; + } + + bool isFake; + aVolume->GetIsFake(&isFake); + if (mIsFake != isFake) { + return false; + } + + bool isSharing; + aVolume->GetIsSharing(&isSharing); + if (mIsSharing != isSharing) { + return false; + } + + bool isFormatting; + aVolume->GetIsFormatting(&isFormatting); + if (mIsFormatting != isFormatting) { + return false; + } + + bool isUnmounting; + aVolume->GetIsUnmounting(&isUnmounting); + if (mIsUnmounting != isUnmounting) { + return false; + } + + bool isRemovable; + aVolume->GetIsRemovable(&isRemovable); + if (mIsRemovable != isRemovable) { + return false; + } + + bool isHotSwappable; + aVolume->GetIsHotSwappable(&isHotSwappable); + if (mIsHotSwappable != isHotSwappable) { + return false; + } + + return true; +} + +NS_IMETHODIMP nsVolume::GetIsMediaPresent(bool* aIsMediaPresent) +{ + *aIsMediaPresent = mIsMediaPresent; + return NS_OK; +} + +NS_IMETHODIMP nsVolume::GetIsMountLocked(bool* aIsMountLocked) +{ + *aIsMountLocked = mMountLocked; + return NS_OK; +} + +NS_IMETHODIMP nsVolume::GetIsSharing(bool* aIsSharing) +{ + *aIsSharing = mIsSharing; + return NS_OK; +} + +NS_IMETHODIMP nsVolume::GetIsFormatting(bool* aIsFormatting) +{ + *aIsFormatting = mIsFormatting; + return NS_OK; +} + +NS_IMETHODIMP nsVolume::GetIsUnmounting(bool* aIsUnmounting) +{ + *aIsUnmounting = mIsUnmounting; + return NS_OK; +} + +NS_IMETHODIMP nsVolume::GetName(nsAString& aName) +{ + aName = mName; + return NS_OK; +} + +NS_IMETHODIMP nsVolume::GetMountGeneration(int32_t* aMountGeneration) +{ + *aMountGeneration = mMountGeneration; + return NS_OK; +} + +NS_IMETHODIMP nsVolume::GetMountLockName(nsAString& aMountLockName) +{ + aMountLockName = NS_LITERAL_STRING("volume-") + Name(); + aMountLockName.AppendPrintf("-%d", mMountGeneration); + + return NS_OK; +} + +NS_IMETHODIMP nsVolume::GetMountPoint(nsAString& aMountPoint) +{ + aMountPoint = mMountPoint; + return NS_OK; +} + +NS_IMETHODIMP nsVolume::GetState(int32_t* aState) +{ + *aState = mState; + return NS_OK; +} + +NS_IMETHODIMP nsVolume::GetStats(nsIVolumeStat **aResult) +{ + if (mState != STATE_MOUNTED) { + return NS_ERROR_NOT_AVAILABLE; + } + + NS_IF_ADDREF(*aResult = new nsVolumeStat(mMountPoint)); + return NS_OK; +} + +NS_IMETHODIMP nsVolume::GetIsFake(bool *aIsFake) +{ + *aIsFake = mIsFake; + return NS_OK; +} + +NS_IMETHODIMP nsVolume::GetIsRemovable(bool *aIsRemovable) +{ + *aIsRemovable = mIsRemovable; + return NS_OK; +} + +NS_IMETHODIMP nsVolume::GetIsHotSwappable(bool *aIsHotSwappable) +{ + *aIsHotSwappable = mIsHotSwappable; + return NS_OK; +} + +NS_IMETHODIMP nsVolume::Format() +{ + MOZ_ASSERT(XRE_IsParentProcess()); + + XRE_GetIOMessageLoop()->PostTask( + NewRunnableFunction(FormatVolumeIOThread, NameStr())); + + return NS_OK; +} + +/* static */ +void nsVolume::FormatVolumeIOThread(const nsCString& aVolume) +{ + MOZ_ASSERT(XRE_IsParentProcess()); + + MOZ_ASSERT(MessageLoop::current() == XRE_GetIOMessageLoop()); + if (VolumeManager::State() != VolumeManager::VOLUMES_READY) { + return; + } + + AutoMounterFormatVolume(aVolume); +} + +NS_IMETHODIMP nsVolume::Mount() +{ + MOZ_ASSERT(XRE_IsParentProcess()); + + XRE_GetIOMessageLoop()->PostTask( + NewRunnableFunction(MountVolumeIOThread, NameStr())); + + return NS_OK; +} + +/* static */ +void nsVolume::MountVolumeIOThread(const nsCString& aVolume) +{ + MOZ_ASSERT(XRE_IsParentProcess()); + + MOZ_ASSERT(MessageLoop::current() == XRE_GetIOMessageLoop()); + if (VolumeManager::State() != VolumeManager::VOLUMES_READY) { + return; + } + + AutoMounterMountVolume(aVolume); +} + +NS_IMETHODIMP nsVolume::Unmount() +{ + MOZ_ASSERT(XRE_IsParentProcess()); + + XRE_GetIOMessageLoop()->PostTask( + NewRunnableFunction(UnmountVolumeIOThread, NameStr())); + + return NS_OK; +} + +/* static */ +void nsVolume::UnmountVolumeIOThread(const nsCString& aVolume) +{ + MOZ_ASSERT(XRE_IsParentProcess()); + + MOZ_ASSERT(MessageLoop::current() == XRE_GetIOMessageLoop()); + if (VolumeManager::State() != VolumeManager::VOLUMES_READY) { + return; + } + + AutoMounterUnmountVolume(aVolume); +} + +void +nsVolume::LogState() const +{ + if (mState == nsIVolume::STATE_MOUNTED) { + LOG("nsVolume: %s state %s @ '%s' gen %d locked %d fake %d " + "media %d sharing %d formatting %d unmounting %d removable %d hotswappable %d", + NameStr().get(), StateStr(), MountPointStr().get(), + MountGeneration(), (int)IsMountLocked(), (int)IsFake(), + (int)IsMediaPresent(), (int)IsSharing(), + (int)IsFormatting(), (int)IsUnmounting(), + (int)IsRemovable(), (int)IsHotSwappable()); + return; + } + + LOG("nsVolume: %s state %s", NameStr().get(), StateStr()); +} + +void nsVolume::UpdateMountLock(nsVolume* aOldVolume) +{ + MOZ_ASSERT(NS_IsMainThread()); + + bool oldMountLocked = aOldVolume ? aOldVolume->mMountLocked : false; + if (mState != nsIVolume::STATE_MOUNTED) { + // Since we're not in the mounted state, we need to + // forgot whatever mount generation we may have had. + mMountGeneration = -1; + mMountLocked = oldMountLocked; + return; + } + + int32_t oldMountGeneration = aOldVolume ? aOldVolume->mMountGeneration : -1; + if (mMountGeneration == oldMountGeneration) { + // No change in mount generation, nothing else to do + mMountLocked = oldMountLocked; + return; + } + + if (!XRE_IsParentProcess()) { + // Child processes just track the state, not maintain it. + return; + } + + // Notify the Volume on IOThread whether the volume is locked or not. + nsCOMPtr<nsIPowerManagerService> pmService = + do_GetService(POWERMANAGERSERVICE_CONTRACTID); + if (!pmService) { + return; + } + nsString mountLockName; + GetMountLockName(mountLockName); + nsString mountLockState; + pmService->GetWakeLockState(mountLockName, mountLockState); + UpdateMountLock(mountLockState); +} + +void +nsVolume::UpdateMountLock(const nsAString& aMountLockState) +{ + MOZ_ASSERT(XRE_IsParentProcess()); + MOZ_ASSERT(NS_IsMainThread()); + + // There are 3 states, unlocked, locked-background, and locked-foreground + // I figured it was easier to use negtive logic and compare for unlocked. + UpdateMountLock(!aMountLockState.EqualsLiteral("unlocked")); +} + +void +nsVolume::UpdateMountLock(bool aMountLocked) +{ + MOZ_ASSERT(XRE_IsParentProcess()); + MOZ_ASSERT(NS_IsMainThread()); + + if (aMountLocked == mMountLocked) { + return; + } + // The locked/unlocked state changed. Tell IOThread about it. + mMountLocked = aMountLocked; + LogState(); + XRE_GetIOMessageLoop()->PostTask( + NewRunnableFunction(Volume::UpdateMountLock, + NS_LossyConvertUTF16toASCII(Name()), + MountGeneration(), aMountLocked)); +} + +void +nsVolume::SetIsFake(bool aIsFake) +{ + mIsFake = aIsFake; + if (mIsFake) { + // The media is always present for fake volumes. + mIsMediaPresent = true; + MOZ_ASSERT(!mIsSharing); + } +} + +void +nsVolume::SetIsRemovable(bool aIsRemovable) +{ + mIsRemovable = aIsRemovable; + if (!mIsRemovable) { + mIsHotSwappable = false; + } +} + +void +nsVolume::SetIsHotSwappable(bool aIsHotSwappable) +{ + mIsHotSwappable = aIsHotSwappable; + if (mIsHotSwappable) { + mIsRemovable = true; + } +} + +void +nsVolume::SetState(int32_t aState) +{ + static int32_t sMountGeneration = 0; + + MOZ_ASSERT(XRE_IsParentProcess()); + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(IsFake()); + + if (aState == mState) { + return; + } + + if (aState == nsIVolume::STATE_MOUNTED) { + mMountGeneration = ++sMountGeneration; + } + + mState = aState; +} + +} // system +} // mozilla |