1331 lines
42 KiB
C++
Executable File
1331 lines
42 KiB
C++
Executable File
/*
|
||
* Copyright (C) 2008 The Android Open Source Project
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* http://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <dirent.h>
|
||
#include <errno.h>
|
||
#include <fcntl.h>
|
||
|
||
#include <sys/types.h>
|
||
#include <sys/stat.h>
|
||
#include <sys/types.h>
|
||
#include <sys/mman.h>
|
||
#include <sys/mount.h>
|
||
#include <sys/param.h>
|
||
|
||
#include <linux/kdev_t.h>
|
||
|
||
#include <cutils/properties.h>
|
||
|
||
#include <diskconfig/diskconfig.h>
|
||
|
||
#include <private/android_filesystem_config.h>
|
||
|
||
#define LOG_TAG "Vold"
|
||
|
||
#include <cutils/fs.h>
|
||
#include <cutils/log.h>
|
||
|
||
#include <string>
|
||
|
||
#include "Volume.h"
|
||
#include "VolumeManager.h"
|
||
#include "ResponseCode.h"
|
||
#include "Fat.h"
|
||
#include "Ntfs.h"
|
||
#include "Process.h"
|
||
#include "cryptfs.h"
|
||
#include "Ext4.h"
|
||
|
||
#include "blkid/blkid.h"
|
||
#include "unicode/ucnv.h"
|
||
#define MAX_DEVICE_NODES 32
|
||
|
||
extern "C" void dos_partition_dec(void const *pp, struct dos_partition *d);
|
||
extern "C" void dos_partition_enc(void *pp, struct dos_partition *d);
|
||
|
||
|
||
/*
|
||
* Media directory - stuff that only media_rw user can see
|
||
*/
|
||
const char *Volume::MEDIA_DIR = "/mnt";//"/mnt/media_rw";
|
||
|
||
/*
|
||
* Fuse directory - location where fuse wrapped filesystems go
|
||
*/
|
||
const char *Volume::FUSE_DIR = "/storage";
|
||
|
||
/*
|
||
* Path to external storage where *only* root can access ASEC image files
|
||
*/
|
||
const char *Volume::SEC_ASECDIR_EXT = "/mnt/secure/asec";
|
||
|
||
/*
|
||
* Path to internal storage where *only* root can access ASEC image files
|
||
*/
|
||
const char *Volume::SEC_ASECDIR_INT = "/data/app-asec";
|
||
|
||
/*
|
||
* Path to where secure containers are mounted
|
||
*/
|
||
const char *Volume::ASECDIR = "/mnt/asec";
|
||
|
||
/*
|
||
* Path to where OBBs are mounted
|
||
*/
|
||
const char *Volume::LOOPDIR = "/mnt/obb";
|
||
|
||
/* $_rbox_$_modify_$_huangyonglin: added by huangyonglin for adding the funtion to support the mass storage.*/
|
||
/*
|
||
* Path to where udisk partitions are mounted
|
||
*/
|
||
const char *Volume::SEC_UDISK_PRATITION_DIR ="/mnt/usb_storage/";
|
||
/*
|
||
* Path to where udisk partitions are mounted
|
||
*/
|
||
const char *Volume::SEC_UDISK_PRATITION_DIR_EXTERN_0 = "/mnt/usb_storage/udisk0/";
|
||
const char *Volume::SEC_UDISK_PRATITION_DIR_EXTERN_1 = "/mnt/usb_storage/udisk1/";
|
||
const char *Volume::SEC_UDISK_PRATITION_DIR_EXTERN_2 = "/mnt/usb_storage/udisk2/";
|
||
const char *Volume::SEC_UDISK_PRATITION_DIR_EXTERN_3 = "/mnt/usb_storage/udisk3/";
|
||
const char *Volume::SEC_UDISK_PRATITION_DIR_EXTERN_4 = "/mnt/usb_storage/udisk4/";
|
||
const char *Volume::SEC_UDISK_PRATITION_DIR_EXTERN_5 = "/mnt/usb_storage/udisk5/";
|
||
const char *Volume::SEC_UDISK_INTERNAL_DIR = "/mnt/udiskint";
|
||
|
||
/*
|
||
* used to create mDiskVolumeLabel
|
||
*/
|
||
int Volume::sDiskVolumeLabelNum = 0;//because add a internal harddisk ,edited by hyl
|
||
int Volume::mDiskVolumelNum =0;
|
||
|
||
/*
|
||
* Property of external SD card's state.
|
||
*/
|
||
const char *Volume::PROP_EXTERNAL_STORAGE_STATE = "EXTERNAL_STORAGE_STATE";
|
||
/*# $_rbox_$_modify_$ end */
|
||
|
||
const char *Volume::BLKID_PATH = "/system/bin/blkid";
|
||
|
||
static const char *stateToStr(int state) {
|
||
if (state == Volume::State_Init)
|
||
return "Initializing";
|
||
else if (state == Volume::State_NoMedia)
|
||
return "No-Media";
|
||
else if (state == Volume::State_Idle)
|
||
return "Idle-Unmounted";
|
||
else if (state == Volume::State_Pending)
|
||
return "Pending";
|
||
else if (state == Volume::State_Mounted)
|
||
return "Mounted";
|
||
else if (state == Volume::State_Unmounting)
|
||
return "Unmounting";
|
||
else if (state == Volume::State_Checking)
|
||
return "Checking";
|
||
else if (state == Volume::State_Formatting)
|
||
return "Formatting";
|
||
else if (state == Volume::State_Shared)
|
||
return "Shared-Unmounted";
|
||
else if (state == Volume::State_SharedMnt)
|
||
return "Shared-Mounted";
|
||
else
|
||
return "Unknown-Error";
|
||
}
|
||
|
||
Volume::Volume(VolumeManager *vm, const fstab_rec* rec, int flags) {
|
||
mVm = vm;
|
||
mDebug = false;
|
||
mLabel = strdup(rec->label);
|
||
mUuid = NULL;
|
||
mUserLabel = NULL;
|
||
mState = Volume::State_Init;
|
||
mFlags = flags;
|
||
mCurrentlyMountedKdev = -1;
|
||
mPartIdx = rec->partnum;
|
||
mRetryMount = false;
|
||
mSkipAsec = false;
|
||
|
||
#ifdef VOLD_BOX
|
||
/* $_rbox_$_modify_$_huangyonglin: added by huangyonglin for adding the funtion to support the mass storage.*/
|
||
mDevPath =NULL;
|
||
mUdiskPartition =new UDisk_Partition_Collection();
|
||
//just create disk label for udisk;added by zxg
|
||
memset(mDiskVolumeLabel, 0, sizeof(mDiskVolumeLabel));
|
||
sprintf(mDiskVolumeLabel, "%s%d", UDISK_VOLUME_LABEL_PREFIX, sDiskVolumeLabelNum);
|
||
SLOGE("Volume::Volume mDiskVolumeLabel = %s",mDiskVolumeLabel);
|
||
SLOGE("Volume::Volume mLabel = %s",mLabel);
|
||
if(strncmp(mLabel,"usb_storage",strlen("usb_storage"))==0){
|
||
++sDiskVolumeLabelNum;
|
||
}
|
||
/*# $_rbox_$_modify_$ end */
|
||
#endif
|
||
}
|
||
|
||
Volume::~Volume() {
|
||
#ifdef VOLD_BOX
|
||
/* $_rbox_$_modify_$_huangyonglin: added by huangyonglin for adding the funtion to support the mass storage.*/
|
||
UDisk_Partition_Collection::iterator it;
|
||
if(strncmp(mLabel,"usb_storage",strlen("usb_storage"))==0){
|
||
--sDiskVolumeLabelNum;
|
||
}
|
||
for (it = mUdiskPartition->begin(); it != mUdiskPartition->end(); ++it)
|
||
free(*it);
|
||
delete mUdiskPartition;
|
||
free(mDevPath);
|
||
/*# $_rbox_$_modify_$ end */
|
||
#endif
|
||
|
||
free(mLabel);
|
||
free(mUuid);
|
||
free(mUserLabel);
|
||
}
|
||
|
||
void Volume::setDebug(bool enable) {
|
||
mDebug = enable;
|
||
}
|
||
|
||
dev_t Volume::getDiskDevice() {
|
||
return MKDEV(0, 0);
|
||
};
|
||
|
||
dev_t Volume::getShareDevice() {
|
||
return getDiskDevice();
|
||
}
|
||
|
||
void Volume::handleVolumeShared() {
|
||
}
|
||
|
||
void Volume::handleVolumeUnshared() {
|
||
}
|
||
|
||
int Volume::handleBlockEvent(NetlinkEvent * /*evt*/) {
|
||
errno = ENOSYS;
|
||
return -1;
|
||
}
|
||
|
||
void Volume::setUuid(const char* uuid) {
|
||
char msg[256];
|
||
|
||
if (mUuid) {
|
||
free(mUuid);
|
||
}
|
||
|
||
if (uuid) {
|
||
mUuid = strdup(uuid);
|
||
snprintf(msg, sizeof(msg), "%s %s \"%s\"", getLabel(),
|
||
getFuseMountpoint(), mUuid);
|
||
} else {
|
||
mUuid = NULL;
|
||
snprintf(msg, sizeof(msg), "%s %s", getLabel(), getFuseMountpoint());
|
||
}
|
||
|
||
mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeUuidChange, msg,
|
||
false);
|
||
}
|
||
|
||
void Volume::setUserLabel(const char* userLabel) {
|
||
char msg[256];
|
||
|
||
if (mUserLabel) {
|
||
free(mUserLabel);
|
||
}
|
||
|
||
if (userLabel) {
|
||
mUserLabel = strdup(userLabel);
|
||
snprintf(msg, sizeof(msg), "%s %s \"%s\"", getLabel(),
|
||
getFuseMountpoint(), mUserLabel);
|
||
} else {
|
||
mUserLabel = NULL;
|
||
snprintf(msg, sizeof(msg), "%s %s", getLabel(), getFuseMountpoint());
|
||
}
|
||
|
||
mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeUserLabelChange,
|
||
msg, false);
|
||
}
|
||
|
||
//to inform SDMMC-driver for umounting sdcard. noted by xbw@2011-06-07
|
||
void Volume::notifyStateKernel(int number)
|
||
{
|
||
if(!strncmp(getLabel(),"external_sd", strlen("external_sd")))
|
||
{
|
||
FILE *fp = fopen("/sys/sd-sdio/rescan","w");
|
||
if(fp){
|
||
char kstate[64] = "sd-";
|
||
|
||
if(number == 0) {
|
||
strcat(kstate,"Ready");//strcat(kstate,stateToStr(Volume::State_Ready));
|
||
} else {
|
||
strcat(kstate,stateToStr(mState));
|
||
}
|
||
fputs(kstate,fp);
|
||
SLOGI("Call notifyStateKernel No.%d in the file of Volume.cpp", number);
|
||
fclose(fp);
|
||
} else {
|
||
SLOGI("Error(call No.%d) opening /sys/sd-sdio/rescan in the file of Volume.cpp", number);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/* $_rbox_$_modify_$_huangyonglin: added for adding the mass storage funcion*/
|
||
bool Volume::addPartitionMountFile(char *FilePath)
|
||
{
|
||
int i =0;
|
||
int iret;
|
||
char szName[200];
|
||
UDisk_Partition_Collection::iterator it;
|
||
|
||
for(i =0 ;i<MAX_PARTITIONS_FILE_NUM;i++)
|
||
{
|
||
sprintf(szName,"%sudisk%d",SEC_UDISK_PRATITION_DIR,i);
|
||
iret =access(szName, F_OK);
|
||
if (access(szName, F_OK) != -1)
|
||
continue;
|
||
strcpy(FilePath,szName);
|
||
SLOGE("############ addPartitionMountFile %s",szName);
|
||
return true;
|
||
}
|
||
SLOGE("############ addPartitionMountFile error ##################");
|
||
return false;
|
||
}
|
||
|
||
bool Volume::addPartitionMountFileSuffix(char *filepath) {
|
||
int i = 0;
|
||
char szName[200];
|
||
UDisk_Partition_Collection::iterator it;
|
||
|
||
if(access(filepath, F_OK) == -1)
|
||
return true;
|
||
for(i=1; i<MAX_SAME_PATITION_VOLUME_NAME_COUNTS; ++i) {
|
||
sprintf(szName,"%s(%d)", filepath, i);
|
||
if (access(szName, F_OK) != -1)
|
||
continue;
|
||
sprintf(filepath, "%s", szName);
|
||
SLOGE("############ addPartitionMountFile suffix %s",filepath);
|
||
return true;
|
||
}
|
||
SLOGE("############ addPartitionMountFile suffix error ##################");
|
||
return false;
|
||
}
|
||
|
||
int Volume::addUdiskPartition(int major,int minor)
|
||
{
|
||
UDISK_PARTITION_CONFIG *partition;
|
||
int i =0;
|
||
UDisk_Partition_Collection::iterator it;
|
||
char szLable[100];
|
||
char *pucMountPoint =NULL;
|
||
|
||
SLOGE("addUdiskPartition getLabel = %s.",getLabel());
|
||
|
||
if(strcmp(getLabel(),"udisk1")==0)
|
||
pucMountPoint =(char *)SEC_UDISK_PRATITION_DIR_EXTERN_1;
|
||
else if(strcmp(getLabel(),"udisk2") ==0)
|
||
pucMountPoint =(char *)SEC_UDISK_PRATITION_DIR_EXTERN_2;
|
||
else if(strcmp(getLabel(),"udisk3") ==0)
|
||
pucMountPoint =(char *)SEC_UDISK_PRATITION_DIR_EXTERN_3;
|
||
else if(strcmp(getLabel(),"udisk4") ==0)
|
||
pucMountPoint =(char *)SEC_UDISK_PRATITION_DIR_EXTERN_4;
|
||
else if(strcmp(getLabel(),"udisk5") ==0)
|
||
pucMountPoint =(char *)SEC_UDISK_PRATITION_DIR_EXTERN_5;
|
||
else if(strcmp(getLabel(),"udiskint") ==0)
|
||
pucMountPoint =(char *)SEC_UDISK_INTERNAL_DIR;
|
||
else
|
||
pucMountPoint =(char *)SEC_UDISK_PRATITION_DIR_EXTERN_0;
|
||
|
||
SLOGE("addUdiskPartition pucMountPoint = %s.",pucMountPoint);
|
||
|
||
for(i =0 ;i<MAX_UDISK_PARTITIONS;i++)
|
||
{
|
||
sprintf(szLable,"udisk%d",i);
|
||
|
||
for (it = mUdiskPartition->begin(); it != mUdiskPartition->end(); ++it)
|
||
{
|
||
if (!strncmp(szLable, (*it)->ucLable,strlen((*it)->ucLable)))
|
||
break;
|
||
}
|
||
|
||
if(it == mUdiskPartition->end())
|
||
{
|
||
partition = (UDISK_PARTITION_CONFIG *)malloc(sizeof(UDISK_PARTITION_CONFIG)+1);
|
||
memset(partition,0,sizeof(sizeof(UDISK_PARTITION_CONFIG)+1));
|
||
strcpy(partition->ucLable,szLable);
|
||
sprintf(partition->ucMountPoint,"%s%s",pucMountPoint,szLable);
|
||
partition->imajor =major;
|
||
partition->iminor =minor;
|
||
partition->mState =State_Init;
|
||
|
||
mUdiskPartition->push_back(partition);
|
||
for (it = mUdiskPartition->begin(); it != mUdiskPartition->end(); ++it)
|
||
SLOGE("############ addUdiskPartition ucMountPoint=%s mState =%d##################",(*it)->ucMountPoint,(*it)->mState);
|
||
|
||
return i;
|
||
}
|
||
}
|
||
|
||
SLOGE("############ addUdiskPartition error ##################");
|
||
return -1;
|
||
}
|
||
|
||
void Volume::RemoveUdiskPartition(const char *Mountpoint)
|
||
{
|
||
UDISK_PARTITION_CONFIG *partition;
|
||
int ii =0;
|
||
UDisk_Partition_Collection::iterator it;
|
||
char szLable[100];
|
||
|
||
for (it = mUdiskPartition->begin(); it != mUdiskPartition->end(); ++it)
|
||
{
|
||
// SLOGE("############ RemoveUdiskPartition remove =%s##################",(*it)->ucMountPoint);
|
||
if (!strncmp(Mountpoint, (*it)->ucMountPoint,strlen((*it)->ucMountPoint)))
|
||
{
|
||
mUdiskPartition->erase(it);
|
||
return ;
|
||
}
|
||
}
|
||
|
||
SLOGE("############ RemoveUdiskPartition error no such Mountpoint =%s##################",Mountpoint);
|
||
}
|
||
const char *Volume::setDevPath(const char *DevPath)
|
||
{
|
||
if(mDevPath)
|
||
{
|
||
free(mDevPath);
|
||
}
|
||
if(DevPath)
|
||
mDevPath = strdup(DevPath);
|
||
else
|
||
mDevPath =NULL;
|
||
return mDevPath;
|
||
}
|
||
void Volume::displayItem()
|
||
{
|
||
UDisk_Partition_Collection::iterator it;
|
||
|
||
SLOGE("############ displayItem#########");
|
||
for (it = mUdiskPartition->begin(); it != mUdiskPartition->end(); ++it)
|
||
SLOGE(" ucMountPoint=%s szLable =%s##################",(*it)->ucMountPoint,(*it)->ucLable);
|
||
SLOGE("############ displayItem end#########");
|
||
}
|
||
|
||
UDISK_PARTITION_CONFIG *Volume::getPartitionState(int major,int minor)
|
||
{
|
||
UDisk_Partition_Collection::iterator it;
|
||
int i;
|
||
int oldState ;
|
||
for (it = mUdiskPartition->begin(); it != mUdiskPartition->end(); ++it)
|
||
{
|
||
if ((*it)->imajor ==major && (*it)->iminor ==minor)
|
||
{
|
||
return (*it);
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
bool Volume::blkid_get_Device_value(const char *tagname,const char *devname,char *pRetType)
|
||
{
|
||
bool iRet =false;
|
||
char *pfstype;
|
||
blkid_cache cache = NULL;
|
||
blkid_get_cache(&cache, "/dev/null");
|
||
pfstype = blkid_get_tag_value(cache, tagname,devname);
|
||
if(pfstype)
|
||
{
|
||
iRet =true;
|
||
strcpy(pRetType,pfstype);
|
||
free(pfstype);
|
||
pfstype =NULL;
|
||
}
|
||
return iRet;
|
||
}
|
||
|
||
int Volume::mountUdiskVol() {
|
||
dev_t deviceNodes[4];
|
||
int n, i, rc = 0;
|
||
char errmsg[255];
|
||
int istate ;
|
||
|
||
istate =getState();
|
||
SLOGE("mountUdiskVol istate = %d",istate);
|
||
if (istate == Volume::State_NoMedia) {
|
||
snprintf(errmsg, sizeof(errmsg),
|
||
"Volume %s %s mount failed - no media",
|
||
getLabel(), getMountpoint());
|
||
mVm->getBroadcaster()->sendBroadcast(
|
||
ResponseCode::VolumeMountFailedNoMedia,
|
||
errmsg, false);
|
||
errno = ENODEV;
|
||
return -1;
|
||
}
|
||
else if (istate != Volume::State_Idle) {
|
||
|
||
errno = EBUSY;
|
||
//$_rbox_$_modify_$_lijiehong: change to avoid udisk mount failure.
|
||
SLOGW("mountVol errno = EBUSY istate =%d, retry..**************************************",istate);
|
||
if (getState() == Volume::State_Pending) {
|
||
mRetryMount = true;
|
||
}
|
||
//$_rbox_$_modify_$ end
|
||
return -1;
|
||
}
|
||
|
||
{
|
||
UDisk_Partition_Collection::iterator it;
|
||
char szType[50];
|
||
char szVolume[255];
|
||
char devicePath[256];
|
||
bool bSucceed =false;
|
||
int iMountRet =false;
|
||
int bUsbDiskMount =false;
|
||
int imajor,iminor;
|
||
char szTempBuf[256];
|
||
mDiskVolumelNum =0;
|
||
setState(Volume::State_Checking);
|
||
CHANGE_ANDROIDFILESYSTEM_TO_READWRITE;
|
||
//to mkdir the disk mount file
|
||
SLOGE("mountUdiskVol getLabel = %s.",getLabel());
|
||
if(!strcmp(getLabel(),"udiskint"))
|
||
{
|
||
snprintf(mDiskMountFilePathName, sizeof(mDiskMountFilePathName), "%s", SEC_UDISK_INTERNAL_DIR);
|
||
}
|
||
else
|
||
{
|
||
snprintf(mDiskMountFilePathName, sizeof(mDiskMountFilePathName), "%s%s", SEC_UDISK_PRATITION_DIR, mDiskVolumeLabel);
|
||
}
|
||
SLOGE("mountUdiskVol mDiskMountFilePathName = %s.",mDiskMountFilePathName);
|
||
|
||
mkdir(mDiskMountFilePathName, 0777);
|
||
chmod(mDiskMountFilePathName,0777);
|
||
bUsbDiskMount =false;
|
||
SLOGW("mountVol mDiskVolumelNum =%s",mDiskMountFilePathName);
|
||
|
||
for (it = mUdiskPartition->begin(); it != mUdiskPartition->end();it++)
|
||
{
|
||
imajor =(*it)->imajor;
|
||
iminor =(*it)->iminor;
|
||
|
||
sprintf(devicePath, "/dev/block/vold/%d:%d", imajor,iminor);
|
||
|
||
SLOGE("%s 1111being considered for volume %s %s ", devicePath, (*it)->ucFilePathName, (*it)->ucLable);
|
||
memset(szType,0,sizeof(szType));
|
||
memset(szVolume,0,sizeof(szVolume));
|
||
blkid_get_Device_value("TYPE",devicePath,szType);
|
||
SLOGE("#######mUdiskPartition size: %d szType =%s",mUdiskPartition->size(),szType);
|
||
// if(mUdiskPartition->size() >2)
|
||
{
|
||
|
||
if(!strcmp(szType,"ntfs"))
|
||
{
|
||
blkid_get_Device_value("LABEL",devicePath,szVolume);
|
||
sprintf((*it)->ucFilePathName, "%s/%s", mDiskMountFilePathName, szVolume);
|
||
}
|
||
else
|
||
sprintf((*it)->ucFilePathName, "%s/%s", mDiskMountFilePathName, (*it)->ucLable);
|
||
SLOGE("ucFilePathName:%s szType=%s", (*it)->ucFilePathName,szType);
|
||
|
||
//if(addPartitionMountFile((*it)->ucFilePathName) ==false)
|
||
// break;
|
||
//now just try to get ntfs partition label
|
||
|
||
if(addPartitionMountFileSuffix((*it)->ucFilePathName) == false)
|
||
break;
|
||
SLOGE("FilePathName:%s szType=%s", (*it)->ucFilePathName,szType);
|
||
mkdir((*it)->ucFilePathName, 0700);
|
||
}
|
||
//else
|
||
// sprintf((*it)->ucFilePathName, "%s", mDiskMountFilePathName);
|
||
errno = 0;
|
||
iMountRet =false;
|
||
|
||
|
||
if(!strcmp(szType,"vfat"))
|
||
{
|
||
if (Fat::doMount(devicePath, (*it)->ucFilePathName, false, false, false,
|
||
1000, 1015, 0002, true) ==0)
|
||
{
|
||
iMountRet =true;
|
||
bUsbDiskMount =true;
|
||
}
|
||
}
|
||
else if(!strcmp(szType,"ntfs"))
|
||
{
|
||
if(Ntfs::doMount(devicePath, (*it)->ucFilePathName, false, 1000,1000)==0)
|
||
{
|
||
iMountRet =true;
|
||
bUsbDiskMount =true;
|
||
}
|
||
}
|
||
else if(!strcmp(szType,"ext2"))
|
||
{
|
||
if(Ext2::doMount(devicePath, (*it)->ucFilePathName, false, false,false)==0)
|
||
{
|
||
iMountRet =true;
|
||
bUsbDiskMount =true;
|
||
}
|
||
|
||
}
|
||
|
||
else if(!strcmp(szType,"ext3"))
|
||
{
|
||
if(Ext3::doMount(devicePath, (*it)->ucFilePathName, false, false,false)==0)
|
||
{
|
||
iMountRet =true;
|
||
bUsbDiskMount =true;
|
||
}
|
||
|
||
}
|
||
|
||
else if(!strcmp(szType,"ext4"))
|
||
{
|
||
if(Ext4::doMount(devicePath, (*it)->ucFilePathName, false, false,false)==0)
|
||
{
|
||
iMountRet =true;
|
||
bUsbDiskMount =true;
|
||
}
|
||
}
|
||
|
||
|
||
if(iMountRet ==false)
|
||
{
|
||
// if(mUdiskPartition->size() >2)
|
||
rmdir((*it)->ucFilePathName);
|
||
SLOGE("earse succed!!!");
|
||
SLOGE("%s failed to mount via %s (%s)",devicePath,szType,strerror(errno));
|
||
}
|
||
else
|
||
{
|
||
SLOGE("mount vfat %s succed!!!",(*it)->ucFilePathName);
|
||
bSucceed =true;
|
||
//mDiskVolumelMinors[mDiskVolumelNum++] =iminor;
|
||
}
|
||
}
|
||
if(bSucceed)
|
||
{
|
||
CHANGE_ANDROIDFILESYSTEM_TO_READONLY;
|
||
setState(Volume::State_Mounted);
|
||
return 0;
|
||
}
|
||
else
|
||
{
|
||
if(bUsbDiskMount==false)
|
||
rmdir(mDiskMountFilePathName);
|
||
CHANGE_ANDROIDFILESYSTEM_TO_READONLY;
|
||
setState(Volume::State_Idle);
|
||
setDevPath(NULL);
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
int Volume::unmountUdiskVol(const char *label, bool force)
|
||
{
|
||
int i;
|
||
char Mountpoint[55];
|
||
int istate ;
|
||
UDisk_Partition_Collection::iterator it;
|
||
|
||
istate =getState();
|
||
|
||
if (istate == Volume::State_NoMedia) {
|
||
SLOGW("Attempt to unmount failed State_NoMedia ");
|
||
errno = ENODEV;
|
||
return -1;
|
||
}
|
||
|
||
if (istate != Volume::State_Mounted) {
|
||
SLOGW("Attempt to unmount volume which isn't mounted (%d)\n",istate);
|
||
errno = EBUSY;
|
||
return -1;
|
||
}
|
||
|
||
|
||
setState(Volume::State_Unmounting);
|
||
CHANGE_ANDROIDFILESYSTEM_TO_READWRITE;
|
||
SLOGE("1********************************");
|
||
/* if(!strcmp(getLabel(),"udiskint"))
|
||
{
|
||
for (it = mUdiskPartition->begin(); it != mUdiskPartition->end(); ++it)
|
||
{
|
||
SLOGE("######### del %s", (*it)->ucFilePathName);
|
||
|
||
//Finally, unmount the actual block device from the staging dir
|
||
|
||
if (0 !=doUnmount((*it)->ucFilePathName, force)) {
|
||
SLOGE("Failed to unmount %s (%s)", (*it)->ucFilePathName, strerror(errno));
|
||
//goto out_nomedia;
|
||
}
|
||
else
|
||
{
|
||
SLOGI("%s unmounted sucessfully", (*it)->ucFilePathName);
|
||
}
|
||
rmdir((*it)->ucFilePathName);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for (it = mUdiskPartition->begin(); it != mUdiskPartition->end();)
|
||
{
|
||
SLOGE("######### del %s", (*it)->ucFilePathName);
|
||
|
||
//Finally, unmount the actual block device from the staging dir
|
||
|
||
if (0 !=doUnmount((*it)->ucFilePathName, force)) {
|
||
SLOGE("Failed to unmount %s (%s)", (*it)->ucFilePathName, strerror(errno));
|
||
}
|
||
else
|
||
{
|
||
SLOGI("%s unmounted sucessfully", (*it)->ucFilePathName);
|
||
}
|
||
rmdir((*it)->ucFilePathName);
|
||
|
||
it =mUdiskPartition->erase(it);
|
||
|
||
if(it ==mUdiskPartition->end())
|
||
break;
|
||
}
|
||
}*/
|
||
|
||
for (it = mUdiskPartition->begin(); it != mUdiskPartition->end(); ++it)
|
||
{
|
||
SLOGE("######### del %s", (*it)->ucFilePathName);
|
||
|
||
//Finally, unmount the actual block device from the staging dir
|
||
|
||
if (0 !=doUnmount((*it)->ucFilePathName, force)) {
|
||
SLOGE("Failed to unmount %s (%s)", (*it)->ucFilePathName, strerror(errno));
|
||
//goto out_nomedia;
|
||
}
|
||
else
|
||
{
|
||
SLOGI("%s unmounted sucessfully", (*it)->ucFilePathName);
|
||
}
|
||
rmdir((*it)->ucFilePathName);
|
||
}
|
||
SLOGE("2********************************");
|
||
|
||
rmdir(mDiskMountFilePathName);
|
||
CHANGE_ANDROIDFILESYSTEM_TO_READONLY;
|
||
system("sync");
|
||
setState(Volume::State_Idle);
|
||
return 0;
|
||
}
|
||
/* $_rbox_$_modify_$ end */
|
||
|
||
|
||
|
||
void Volume::setState(int state) {
|
||
char msg[255];
|
||
int oldState = mState;
|
||
|
||
if (oldState == state) {
|
||
SLOGW("Duplicate state (%d)\n", state);
|
||
return;
|
||
}
|
||
|
||
if ((oldState == Volume::State_Pending) && (state != Volume::State_Idle)) {
|
||
mRetryMount = false;
|
||
}
|
||
|
||
mState = state;
|
||
notifyStateKernel(1);//add by xbw
|
||
|
||
SLOGD("Volume %s state changing %d (%s) -> %d (%s)", mLabel,
|
||
oldState, stateToStr(oldState), mState, stateToStr(mState));
|
||
snprintf(msg, sizeof(msg),
|
||
"Volume %s %s state changed from %d (%s) to %d (%s)", getLabel(),
|
||
getFuseMountpoint(), oldState, stateToStr(oldState), mState,
|
||
stateToStr(mState));
|
||
|
||
mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeStateChange,
|
||
msg, false);
|
||
}
|
||
|
||
int Volume::createDeviceNode(const char *path, int major, int minor) {
|
||
mode_t mode = 0660 | S_IFBLK;
|
||
dev_t dev = (major << 8) | minor;
|
||
if (mknod(path, mode, dev) < 0) {
|
||
if (errno != EEXIST) {
|
||
return -1;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int Volume::formatVol(bool wipe) {
|
||
|
||
if (getState() == Volume::State_NoMedia) {
|
||
errno = ENODEV;
|
||
return -1;
|
||
} else if (getState() != Volume::State_Idle) {
|
||
errno = EBUSY;
|
||
return -1;
|
||
}
|
||
|
||
if (isMountpointMounted(getMountpoint())) {
|
||
SLOGW("Volume is idle but appears to be mounted - fixing");
|
||
setState(Volume::State_Mounted);
|
||
// mCurrentlyMountedKdev = XXX
|
||
errno = EBUSY;
|
||
return -1;
|
||
}
|
||
|
||
bool formatEntireDevice = (mPartIdx == -1);
|
||
char devicePath[255];
|
||
char label[PROPERTY_VALUE_MAX] = "";
|
||
dev_t diskNode = getDiskDevice();
|
||
dev_t partNode =
|
||
MKDEV(MAJOR(diskNode),
|
||
MINOR(diskNode) + (formatEntireDevice ? 1 : mPartIdx));
|
||
|
||
setState(Volume::State_Formatting);
|
||
|
||
int ret = -1;
|
||
// Only initialize the MBR if we are formatting the entire device
|
||
if (!strcmp(getLabel(),"internal_sd")) {
|
||
property_get("UserVolumeLabel", label, "");
|
||
formatEntireDevice = false;
|
||
}
|
||
if (formatEntireDevice) {
|
||
sprintf(devicePath, "/dev/block/vold/%d:%d",
|
||
major(diskNode), minor(diskNode));
|
||
|
||
if (initializeMbr(devicePath)) {
|
||
SLOGE("Failed to initialize MBR (%s)", strerror(errno));
|
||
goto err;
|
||
}
|
||
}
|
||
|
||
if (!strcmp(getLabel(),"internal_sd") && (major(diskNode) != 179)) {
|
||
sprintf(devicePath, "/dev/block/vold/%d:%d",
|
||
major(diskNode), minor(diskNode));
|
||
} else {
|
||
sprintf(devicePath, "/dev/block/vold/%d:%d",
|
||
major(partNode), minor(partNode));
|
||
}
|
||
|
||
if (mDebug) {
|
||
SLOGI("Formatting volume %s (%s)", getLabel(), devicePath);
|
||
}
|
||
|
||
if (Fat::format(devicePath, 0, wipe,label)) {
|
||
SLOGE("Failed to format (%s)", strerror(errno));
|
||
goto err;
|
||
}
|
||
if (!strcmp(getLabel(),"internal_sd")) {
|
||
system("sync");
|
||
}
|
||
ret = 0;
|
||
|
||
err:
|
||
setState(Volume::State_Idle);
|
||
return ret;
|
||
}
|
||
|
||
bool Volume::isMountpointMounted(const char *path) {
|
||
char device[256];
|
||
char mount_path[256];
|
||
char rest[256];
|
||
FILE *fp;
|
||
char line[1024];
|
||
//SLOGE("isMountpointMounted path %s.",path);
|
||
if (!(fp = fopen("/proc/mounts", "r"))) {
|
||
SLOGE("Error opening /proc/mounts (%s)", strerror(errno));
|
||
return false;
|
||
}
|
||
|
||
while(fgets(line, sizeof(line), fp)) {
|
||
line[strlen(line)-1] = '\0';
|
||
sscanf(line, "%255s %255s %255s\n", device, mount_path, rest);
|
||
//SLOGE(" device=%s,mount_path=%s,rest=%s.",device, mount_path, rest);
|
||
#ifndef VOLD_BOX
|
||
if (!strcmp(device, "tmpfs")) {
|
||
continue;
|
||
}
|
||
#endif
|
||
if (!strcmp(mount_path, path)) {
|
||
fclose(fp);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
fclose(fp);
|
||
return false;
|
||
}
|
||
int Volume::mountVol() {
|
||
dev_t deviceNodes[4];
|
||
int n, i, rc = 0;
|
||
char errmsg[255];
|
||
|
||
int flags = getFlags();
|
||
bool providesAsec = (flags & VOL_PROVIDES_ASEC) != 0;
|
||
|
||
// TODO: handle "bind" style mounts, for emulated storage
|
||
|
||
char decrypt_state[PROPERTY_VALUE_MAX];
|
||
char crypto_state[PROPERTY_VALUE_MAX];
|
||
char encrypt_progress[PROPERTY_VALUE_MAX];
|
||
char has_ums[PROPERTY_VALUE_MAX];
|
||
|
||
#ifdef VOLD_BOX
|
||
/* $_rbox_$_modify_$_huangyonglin: added for adding the mass storage funcion*/
|
||
if(strncmp(getLabel(),"usb_storage",strlen("usb_storage"))==0)
|
||
{
|
||
SLOGW("mountVol udisk###############label =%s ",getLabel());
|
||
return mountUdiskVol();
|
||
}
|
||
/* $_rbox_$_modify_$ end */
|
||
#endif
|
||
|
||
property_get("vold.decrypt", decrypt_state, "");/* getprop vold.decrypt == NULL*/
|
||
property_get("vold.encrypt_progress", encrypt_progress, "");/* getprop vold.encrypt_progress == NULL */
|
||
property_get("ro.factory.hasUMS",has_ums, "false");/* getprop ro.factory.hasUMS == true */
|
||
|
||
char getSupNtfs[PROPERTY_VALUE_MAX];
|
||
property_get("ro.factory.storage_suppntfs", getSupNtfs, "true");/* getprop ro.factory.storage_suppntfs == true */
|
||
bool isSupNtfs = !strcmp(getSupNtfs, "true");
|
||
/* Don't try to mount the volumes if we have not yet entered the disk password
|
||
* or are in the process of encrypting.
|
||
*/
|
||
/* D/Vold ( 136): Volume internal_sd state changing 2 (Pending) -> 1 (Idle-Unmounted)*/
|
||
if ((getState() == Volume::State_NoMedia) ||
|
||
((!strcmp(decrypt_state, "1") || (encrypt_progress[0] && encrypt_progress[2] != '0')) && providesAsec)) {
|
||
snprintf(errmsg, sizeof(errmsg),
|
||
"Volume %s %s mount failed - no media",
|
||
getLabel(), getFuseMountpoint());
|
||
mVm->getBroadcaster()->sendBroadcast(
|
||
ResponseCode::VolumeMountFailedNoMedia,
|
||
errmsg, false);
|
||
errno = ENODEV;
|
||
return -1;
|
||
} else if (getState() != Volume::State_Idle) {
|
||
errno = EBUSY;
|
||
if (getState() == Volume::State_Pending) {
|
||
mRetryMount = true;
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
if (isMountpointMounted(getMountpoint())) {
|
||
SLOGW("Volume is idle but appears to be mounted - fixing");
|
||
setState(Volume::State_Mounted);
|
||
// mCurrentlyMountedKdev = XXX
|
||
return 0;
|
||
}
|
||
|
||
n = getDeviceNodes((dev_t *) &deviceNodes, 4);
|
||
if (!n) {
|
||
SLOGE("Failed to get device nodes (%s)\n", strerror(errno));
|
||
return -1;
|
||
}
|
||
else
|
||
{
|
||
SLOGE("deviceNodes[0]= 0x%08x,[1]= 0x%08x,[2]= 0x%08x,[3]= 0x%08x",deviceNodes[0],deviceNodes[1],deviceNodes[2],deviceNodes[3]);
|
||
}
|
||
|
||
/* If we're running encrypted, and the volume is marked as encryptable and nonremovable,
|
||
* and also marked as providing Asec storage, then we need to decrypt
|
||
* that partition, and update the volume object to point to it's new decrypted
|
||
* block device
|
||
*/
|
||
property_get("ro.crypto.state", crypto_state, "");/* getprop ro.crypto.state == unencrypted */
|
||
if (providesAsec &&
|
||
((flags & (VOL_NONREMOVABLE | VOL_ENCRYPTABLE))==(VOL_NONREMOVABLE | VOL_ENCRYPTABLE)) &&
|
||
!strcmp(crypto_state, "encrypted") && !isDecrypted()) {
|
||
char new_sys_path[MAXPATHLEN];
|
||
char nodepath[256];
|
||
int new_major, new_minor;
|
||
|
||
if (n != 1) {
|
||
/* We only expect one device node returned when mounting encryptable volumes */
|
||
SLOGE("Too many device nodes returned when mounting %s\n", getMountpoint());
|
||
return -1;
|
||
}
|
||
|
||
if (cryptfs_setup_volume(getLabel(), MAJOR(deviceNodes[0]), MINOR(deviceNodes[0]),
|
||
new_sys_path, sizeof(new_sys_path),
|
||
&new_major, &new_minor)) {
|
||
SLOGE("Cannot setup encryption mapping for %s\n", getMountpoint());
|
||
return -1;
|
||
}
|
||
/* We now have the new sysfs path for the decrypted block device, and the
|
||
* majore and minor numbers for it. So, create the device, update the
|
||
* path to the new sysfs path, and continue.
|
||
*/
|
||
snprintf(nodepath,
|
||
sizeof(nodepath), "/dev/block/vold/%d:%d",
|
||
new_major, new_minor);
|
||
if (createDeviceNode(nodepath, new_major, new_minor)) {
|
||
SLOGE("Error making device node '%s' (%s)", nodepath,
|
||
strerror(errno));
|
||
}
|
||
|
||
// Todo: Either create sys filename from nodepath, or pass in bogus path so
|
||
// vold ignores state changes on this internal device.
|
||
updateDeviceInfo(nodepath, new_major, new_minor);
|
||
|
||
/* Get the device nodes again, because they just changed */
|
||
n = getDeviceNodes((dev_t *) &deviceNodes, 4);
|
||
if (!n) {
|
||
SLOGE("Failed to get device nodes (%s)\n", strerror(errno));
|
||
return -1;
|
||
}
|
||
else
|
||
{
|
||
SLOGE("deviceNodes[0]= 0x%08x,[1]= 0x%08x,[2]= 0x%08x,[3]= 0x%08x",deviceNodes[0],deviceNodes[1],deviceNodes[2],deviceNodes[3]);
|
||
}
|
||
|
||
}
|
||
|
||
for (i = 0; i < n; i++) {
|
||
char devicePath[255];
|
||
|
||
sprintf(devicePath, "/dev/block/vold/%d:%d", major(deviceNodes[i]),
|
||
minor(deviceNodes[i]));
|
||
|
||
/* /dev/block/vold/179:14 being considered for volume internal_sd,1 */
|
||
SLOGI("%s being considered for volume %s,%d\n ", devicePath, getLabel(),isSupNtfs);
|
||
|
||
errno = 0;
|
||
setState(Volume::State_Checking);
|
||
|
||
if (Fat::check(devicePath) && !isSupNtfs) {
|
||
if (errno == ENODATA) {
|
||
SLOGW("%s does not contain a FAT filesystem\n", devicePath);
|
||
continue;
|
||
}
|
||
errno = EIO;
|
||
/* Badness - abort the mount */
|
||
SLOGE("%s failed FS checks (%s)", devicePath, strerror(errno));
|
||
setState(Volume::State_Idle);
|
||
return -1;
|
||
}
|
||
|
||
errno = 0;
|
||
int gid;
|
||
|
||
if(!strcmp("true",has_ums))//has UMS function ,set group to AID_SDCARD_RW
|
||
{
|
||
/* /dev/block/vold/179:14 /mnt/internal_sd vfat
|
||
* rw,dirsync,nosuid,nodev,noexec,relatime,uid=1000,gid=1015,fmask=0007,dmask=0007,allow_utime=0020,codepage=437,iocharset=iso8859-1,shortname=mixed,utf8,errors=remount-ro 0 0
|
||
* <20><><EFBFBD><EFBFBD>user<65><72><EFBFBD><EFBFBD><EFBFBD><EFBFBD>/mnt/internal_sd user -> /dev/block/mmcblk0p14
|
||
*/
|
||
if (Fat::doMount(devicePath, getMountpoint(), false, false, false,
|
||
AID_SYSTEM,AID_SDCARD_RW, 0007, true)) {
|
||
SLOGE("%s failed to mount via VFAT (%s)\n", devicePath, strerror(errno));
|
||
if(providesAsec){
|
||
mSkipAsec = true;
|
||
SLOGE("---------set mSkipAsec to disable app2sd because mount Vfat fail for %s, mountpoint =%s",getLabel(),getMountpoint());
|
||
}
|
||
if(Ntfs::doMount(devicePath, getMountpoint(), false,AID_SYSTEM,AID_SDCARD_RW)){
|
||
SLOGE("%s failed to mount via VNTFS (%s)\n", devicePath, strerror(errno));
|
||
continue;
|
||
}
|
||
}
|
||
else //mount flash as fat succeed
|
||
{
|
||
mSkipAsec = false;
|
||
// ---------set mSkipAsec to enable app2sd because mount Vfat succeed for internal_sd, mountpoint =/mnt/internal_sd
|
||
SLOGE("---------set mSkipAsec to enable app2sd because mount Vfat succeed for %s, mountpoint =%s",getLabel(),getMountpoint());
|
||
}
|
||
}
|
||
else //do not has ums,set group to AID_MEDIA_RW
|
||
{
|
||
if (Fat::doMount(devicePath, getMountpoint(), false, false, false,
|
||
AID_SYSTEM,AID_MEDIA_RW, 0002, true)) {
|
||
SLOGE("%s failed to mount via VFAT (%s)\n", devicePath, strerror(errno));
|
||
|
||
if(Ntfs::doMount(devicePath, getMountpoint(), false,AID_SYSTEM,AID_MEDIA_RW)){
|
||
SLOGE("%s failed to mount via VNTFS (%s)\n", devicePath, strerror(errno));
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
//blkid identified as /dev/block/vold/179:14: LABEL="ROCKCHIP" UUID="0FE6-0808" TYPE="vfat"
|
||
extractMetadata(devicePath);
|
||
|
||
if (providesAsec&&!mSkipAsec&& mountAsecExternal() != 0) {
|
||
SLOGE("Failed to mount secure area (%s)", strerror(errno));
|
||
umount(getMountpoint());
|
||
setState(Volume::State_Idle);
|
||
return -1;
|
||
}
|
||
|
||
char service[64];
|
||
snprintf(service, 64, "fuse_%s", getLabel());
|
||
property_set("ctl.start", service);
|
||
|
||
setState(Volume::State_Mounted);
|
||
mCurrentlyMountedKdev = deviceNodes[i];/* 179:14 */
|
||
return 0;
|
||
}
|
||
|
||
SLOGE("Volume %s found no suitable devices for mounting :(\n", getLabel());
|
||
setState(Volume::State_Idle);
|
||
|
||
return -1;
|
||
}
|
||
|
||
int Volume::mountAsecExternal() {
|
||
char legacy_path[PATH_MAX];
|
||
char secure_path[PATH_MAX];
|
||
char has_ums[PROPERTY_VALUE_MAX];
|
||
|
||
property_get("ro.factory.hasUMS",has_ums, "false");
|
||
|
||
|
||
snprintf(legacy_path, PATH_MAX, "%s/android_secure", getMountpoint());
|
||
snprintf(secure_path, PATH_MAX, "%s/.android_secure", getMountpoint());
|
||
|
||
// Recover legacy secure path
|
||
if (!access(legacy_path, R_OK | X_OK) && access(secure_path, R_OK | X_OK)) {
|
||
if (rename(legacy_path, secure_path)) {
|
||
SLOGE("Failed to rename legacy asec dir (%s)", strerror(errno));
|
||
}
|
||
}
|
||
|
||
if(!strcmp("true",has_ums))//has UMS function ,set group to AID_SDCARD_RW
|
||
{
|
||
if (fs_prepare_dir(secure_path, 0770, AID_SYSTEM,AID_SDCARD_RW) != 0) {
|
||
return -1;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (fs_prepare_dir(secure_path, 0770, AID_SYSTEM,AID_MEDIA_RW) != 0) {
|
||
SLOGW("fs_prepare_dir failed: %s", strerror(errno));
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
if (mount(secure_path, SEC_ASECDIR_EXT, "", MS_BIND, NULL)) {
|
||
SLOGE("Failed to bind mount points %s -> %s (%s)", secure_path,
|
||
SEC_ASECDIR_EXT, strerror(errno));
|
||
return -1;
|
||
}
|
||
property_set("sys.vold.hasAsec","true");
|
||
return 0;
|
||
}
|
||
|
||
int Volume::doUnmount(const char *path, bool force) {
|
||
int retries = 10;
|
||
|
||
if (mDebug) {
|
||
SLOGD("Unmounting {%s}, force = %d", path, force);
|
||
}
|
||
|
||
while (retries--) {
|
||
if (!umount(path) || errno == EINVAL || errno == ENOENT) {
|
||
SLOGI("%s sucessfully unmounted", path);
|
||
notifyStateKernel(2);
|
||
return 0;
|
||
}
|
||
|
||
int action = 0;
|
||
notifyStateKernel(3);
|
||
if (force) {
|
||
if (retries == 1) {
|
||
action = 2; // SIGKILL
|
||
} else if (retries == 2) {
|
||
action = 1; // SIGHUP
|
||
}
|
||
}
|
||
|
||
SLOGW("Failed to unmount %s (%s, retries %d, action %d)",
|
||
path, strerror(errno), retries, action);
|
||
|
||
Process::killProcessesWithOpenFiles(path, action);
|
||
usleep(1000*30);
|
||
}
|
||
errno = EBUSY;
|
||
SLOGE("Giving up on unmount %s (%s)", path, strerror(errno));
|
||
return -1;
|
||
}
|
||
|
||
int Volume::unmountVol(bool force, bool revert) {
|
||
int i, rc;
|
||
|
||
int flags = getFlags();
|
||
bool providesAsec = ((flags & VOL_PROVIDES_ASEC) != 0)&&(!mSkipAsec);
|
||
revert = mPartIdx == -1 ? false : revert;
|
||
|
||
if (getState() != Volume::State_Mounted) {
|
||
SLOGE("Volume %s unmount request when not mounted", getLabel());
|
||
errno = EINVAL;
|
||
return UNMOUNT_NOT_MOUNTED_ERR;
|
||
}
|
||
|
||
setState(Volume::State_Unmounting);
|
||
usleep(1000 * 1000); // Give the framework some time to react
|
||
|
||
char service[64];
|
||
snprintf(service, 64, "fuse_%s", getLabel());
|
||
property_set("ctl.stop", service);
|
||
/* Give it a chance to stop. I wish we had a synchronous way to determine this... */
|
||
sleep(1);
|
||
|
||
// TODO: determine failure mode if FUSE times out
|
||
|
||
if (providesAsec) {
|
||
if(doUnmount(Volume::SEC_ASECDIR_EXT, force) != 0)
|
||
{
|
||
SLOGE("Failed to unmount secure area on %s (%s)", getMountpoint(), strerror(errno));
|
||
goto out_mounted;
|
||
}
|
||
else
|
||
{
|
||
property_set("sys.vold.hasAsec","false");
|
||
SLOGE("Succeed to umount secure area on %s",getMountpoint());
|
||
}
|
||
}
|
||
|
||
/* Now that the fuse daemon is dead, unmount it */
|
||
if (doUnmount(getFuseMountpoint(), force) != 0) {
|
||
SLOGE("Failed to unmount %s (%s)", getFuseMountpoint(), strerror(errno));
|
||
//goto fail_remount_secure;
|
||
}
|
||
|
||
/* Unmount the real sd card */
|
||
if (doUnmount(getMountpoint(), force) != 0) {
|
||
SLOGE("Failed to unmount %s (%s)", getMountpoint(), strerror(errno));
|
||
goto fail_remount_secure;
|
||
}
|
||
|
||
SLOGI("%s unmounted successfully", getMountpoint());
|
||
|
||
/* If this is an encrypted volume, and we've been asked to undo
|
||
* the crypto mapping, then revert the dm-crypt mapping, and revert
|
||
* the device info to the original values.
|
||
*/
|
||
if (revert && isDecrypted()) {
|
||
cryptfs_revert_volume(getLabel());
|
||
revertDeviceInfo();
|
||
SLOGI("Encrypted volume %s reverted successfully", getMountpoint());
|
||
}
|
||
|
||
setUuid(NULL);
|
||
setUserLabel(NULL);
|
||
setState(Volume::State_Idle);
|
||
mCurrentlyMountedKdev = -1;
|
||
return 0;
|
||
|
||
fail_remount_secure:
|
||
if (providesAsec && mountAsecExternal() != 0) {
|
||
SLOGE("Failed to remount secure area (%s)", strerror(errno));
|
||
goto out_nomedia;
|
||
}
|
||
|
||
out_mounted:
|
||
setState(Volume::State_Mounted);
|
||
return -1;
|
||
|
||
out_nomedia:
|
||
setState(Volume::State_NoMedia);
|
||
return -1;
|
||
}
|
||
|
||
int Volume::initializeMbr(const char *deviceNode) {
|
||
struct disk_info dinfo;
|
||
|
||
memset(&dinfo, 0, sizeof(dinfo));
|
||
|
||
if (!(dinfo.part_lst = (struct part_info *) malloc(MAX_NUM_PARTS * sizeof(struct part_info)))) {
|
||
SLOGE("Failed to malloc prt_lst");
|
||
return -1;
|
||
}
|
||
|
||
memset(dinfo.part_lst, 0, MAX_NUM_PARTS * sizeof(struct part_info));
|
||
dinfo.device = strdup(deviceNode);
|
||
dinfo.scheme = PART_SCHEME_MBR;
|
||
dinfo.sect_size = 512;
|
||
dinfo.skip_lba = 2048;
|
||
dinfo.num_lba = 0;
|
||
dinfo.num_parts = 1;
|
||
|
||
struct part_info *pinfo = &dinfo.part_lst[0];
|
||
|
||
pinfo->name = strdup("android_sdcard");
|
||
pinfo->flags |= PART_ACTIVE_FLAG;
|
||
pinfo->type = PC_PART_TYPE_FAT32;
|
||
pinfo->len_kb = -1;
|
||
|
||
int rc = apply_disk_config(&dinfo, 0);
|
||
|
||
if (rc) {
|
||
SLOGE("Failed to apply disk configuration (%d)", rc);
|
||
goto out;
|
||
}
|
||
|
||
out:
|
||
free(pinfo->name);
|
||
free(dinfo.device);
|
||
free(dinfo.part_lst);
|
||
|
||
return rc;
|
||
}
|
||
|
||
/*
|
||
* Use blkid to extract <20><>ȡ UUID and label from device, since it handles many
|
||
* obscure edge cases around partition types and formats. Always broadcasts
|
||
* updated metadata values.
|
||
*/
|
||
int Volume::extractMetadata(const char* devicePath) {
|
||
int res = 0;
|
||
|
||
std::string cmd;
|
||
cmd = BLKID_PATH;
|
||
cmd += " -c /dev/null ";
|
||
cmd += devicePath;
|
||
|
||
FILE* fp = popen(cmd.c_str(), "r");
|
||
if (!fp) {
|
||
ALOGE("Failed to run %s: %s", cmd.c_str(), strerror(errno));
|
||
res = -1;
|
||
goto done;
|
||
}
|
||
|
||
char line[1024];
|
||
char value[128];
|
||
if (fgets(line, sizeof(line), fp) != NULL) {
|
||
//blkid identified as /dev/block/vold/179:14: LABEL="ROCKCHIP" UUID="0FE6-0808" TYPE="vfat"
|
||
ALOGD("blkid identified as %s", line);
|
||
|
||
char* start = strstr(line, "UUID=");
|
||
if (start != NULL && sscanf(start + 5, "\"%127[^\"]\"", value) == 1) {
|
||
setUuid(value);
|
||
} else {
|
||
setUuid(NULL);
|
||
}
|
||
|
||
start = strstr(line, "LABEL=");
|
||
if (start != NULL && sscanf(start + 6, "\"%127[^\"]\"", value) == 1) {
|
||
setUserLabel(value);
|
||
} else {
|
||
setUserLabel(NULL);
|
||
}
|
||
} else {
|
||
ALOGW("blkid failed to identify %s", devicePath);
|
||
res = -1;
|
||
}
|
||
|
||
pclose(fp);
|
||
|
||
done:
|
||
if (res == -1) {
|
||
setUuid(NULL);
|
||
setUserLabel(NULL);
|
||
}
|
||
return res;
|
||
}
|