gecko-dev/dom/system/gonk/nsVolume.cpp

468 строки
11 KiB
C++

/* 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