Jeff Sharkey
9 years ago
parent
f7e86ead9f
commit
9f18fe7807
@ -1,512 +0,0 @@
|
||||
/*
|
||||
* 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 <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <fnmatch.h>
|
||||
|
||||
#include <linux/kdev_t.h>
|
||||
|
||||
#define LOG_TAG "DirectVolume"
|
||||
|
||||
#include <cutils/log.h>
|
||||
#include <sysutils/NetlinkEvent.h>
|
||||
|
||||
#include "DirectVolume.h"
|
||||
#include "VolumeManager.h"
|
||||
#include "ResponseCode.h"
|
||||
#include "cryptfs.h"
|
||||
|
||||
// #define PARTITION_DEBUG
|
||||
|
||||
PathInfo::PathInfo(const char *p)
|
||||
{
|
||||
warned = false;
|
||||
pattern = strdup(p);
|
||||
|
||||
if (!strchr(pattern, '*')) {
|
||||
patternType = prefix;
|
||||
} else {
|
||||
patternType = wildcard;
|
||||
}
|
||||
}
|
||||
|
||||
PathInfo::~PathInfo()
|
||||
{
|
||||
free(pattern);
|
||||
}
|
||||
|
||||
bool PathInfo::match(const char *path)
|
||||
{
|
||||
switch (patternType) {
|
||||
case prefix:
|
||||
{
|
||||
bool ret = (strncmp(path, pattern, strlen(pattern)) == 0);
|
||||
if (!warned && ret && (strlen(pattern) != strlen(path))) {
|
||||
SLOGW("Deprecated implied prefix pattern detected, please use '%s*' instead", pattern);
|
||||
warned = true;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
case wildcard:
|
||||
return fnmatch(pattern, path, 0) == 0;
|
||||
}
|
||||
SLOGE("Bad matching type");
|
||||
return false;
|
||||
}
|
||||
|
||||
DirectVolume::DirectVolume(VolumeManager *vm, const fstab_rec* rec, int flags) :
|
||||
Volume(vm, rec, flags) {
|
||||
mPaths = new PathCollection();
|
||||
for (int i = 0; i < MAX_PARTITIONS; i++)
|
||||
mPartMinors[i] = -1;
|
||||
mPendingPartCount = 0;
|
||||
mDiskMajor = -1;
|
||||
mDiskMinor = -1;
|
||||
mDiskNumParts = 0;
|
||||
mIsDecrypted = 0;
|
||||
|
||||
if (strcmp(rec->mount_point, "auto") != 0) {
|
||||
ALOGE("Vold managed volumes must have auto mount point; ignoring %s",
|
||||
rec->mount_point);
|
||||
}
|
||||
|
||||
char mount[PATH_MAX];
|
||||
|
||||
snprintf(mount, PATH_MAX, "%s/%s", Volume::MEDIA_DIR, rec->label);
|
||||
mMountpoint = strdup(mount);
|
||||
snprintf(mount, PATH_MAX, "%s/%s", Volume::FUSE_DIR, rec->label);
|
||||
mFuseMountpoint = strdup(mount);
|
||||
|
||||
setState(Volume::State_NoMedia);
|
||||
}
|
||||
|
||||
DirectVolume::~DirectVolume() {
|
||||
PathCollection::iterator it;
|
||||
|
||||
for (it = mPaths->begin(); it != mPaths->end(); ++it)
|
||||
delete *it;
|
||||
delete mPaths;
|
||||
}
|
||||
|
||||
int DirectVolume::addPath(const char *path) {
|
||||
mPaths->push_back(new PathInfo(path));
|
||||
return 0;
|
||||
}
|
||||
|
||||
dev_t DirectVolume::getDiskDevice() {
|
||||
return MKDEV(mDiskMajor, mDiskMinor);
|
||||
}
|
||||
|
||||
dev_t DirectVolume::getShareDevice() {
|
||||
if (mPartIdx != -1) {
|
||||
return MKDEV(mDiskMajor, mPartIdx);
|
||||
} else {
|
||||
return MKDEV(mDiskMajor, mDiskMinor);
|
||||
}
|
||||
}
|
||||
|
||||
void DirectVolume::handleVolumeShared() {
|
||||
setState(Volume::State_Shared);
|
||||
}
|
||||
|
||||
void DirectVolume::handleVolumeUnshared() {
|
||||
setState(Volume::State_Idle);
|
||||
}
|
||||
|
||||
int DirectVolume::handleBlockEvent(NetlinkEvent *evt) {
|
||||
const char *dp = evt->findParam("DEVPATH");
|
||||
|
||||
PathCollection::iterator it;
|
||||
for (it = mPaths->begin(); it != mPaths->end(); ++it) {
|
||||
if ((*it)->match(dp)) {
|
||||
/* We can handle this disk */
|
||||
NetlinkEvent::Action action = evt->getAction();
|
||||
const char *devtype = evt->findParam("DEVTYPE");
|
||||
|
||||
if (action == NetlinkEvent::Action::kAdd) {
|
||||
int major = atoi(evt->findParam("MAJOR"));
|
||||
int minor = atoi(evt->findParam("MINOR"));
|
||||
char nodepath[255];
|
||||
|
||||
snprintf(nodepath,
|
||||
sizeof(nodepath), "/dev/block/vold/%d:%d",
|
||||
major, minor);
|
||||
if (createDeviceNode(nodepath, major, minor)) {
|
||||
SLOGE("Error making device node '%s' (%s)", nodepath,
|
||||
strerror(errno));
|
||||
}
|
||||
if (!strcmp(devtype, "disk")) {
|
||||
handleDiskAdded(dp, evt);
|
||||
} else {
|
||||
handlePartitionAdded(dp, evt);
|
||||
}
|
||||
/* Send notification iff disk is ready (ie all partitions found) */
|
||||
if (getState() == Volume::State_Idle) {
|
||||
char msg[255];
|
||||
|
||||
snprintf(msg, sizeof(msg),
|
||||
"Volume %s %s disk inserted (%d:%d)", getLabel(),
|
||||
getFuseMountpoint(), mDiskMajor, mDiskMinor);
|
||||
mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskInserted,
|
||||
msg, false);
|
||||
}
|
||||
} else if (action == NetlinkEvent::Action::kRemove) {
|
||||
if (!strcmp(devtype, "disk")) {
|
||||
handleDiskRemoved(dp, evt);
|
||||
} else {
|
||||
handlePartitionRemoved(dp, evt);
|
||||
}
|
||||
} else if (action == NetlinkEvent::Action::kChange) {
|
||||
if (!strcmp(devtype, "disk")) {
|
||||
handleDiskChanged(dp, evt);
|
||||
} else {
|
||||
handlePartitionChanged(dp, evt);
|
||||
}
|
||||
} else {
|
||||
SLOGW("Ignoring non add/remove/change event");
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
errno = ENODEV;
|
||||
return -1;
|
||||
}
|
||||
|
||||
void DirectVolume::handleDiskAdded(const char * /*devpath*/,
|
||||
NetlinkEvent *evt) {
|
||||
mDiskMajor = atoi(evt->findParam("MAJOR"));
|
||||
mDiskMinor = atoi(evt->findParam("MINOR"));
|
||||
|
||||
const char *tmp = evt->findParam("NPARTS");
|
||||
if (tmp) {
|
||||
mDiskNumParts = atoi(tmp);
|
||||
} else {
|
||||
SLOGW("Kernel block uevent missing 'NPARTS'");
|
||||
mDiskNumParts = 1;
|
||||
}
|
||||
|
||||
mPendingPartCount = mDiskNumParts;
|
||||
for (int i = 0; i < MAX_PARTITIONS; i++)
|
||||
mPartMinors[i] = -1;
|
||||
|
||||
if (mDiskNumParts == 0) {
|
||||
#ifdef PARTITION_DEBUG
|
||||
SLOGD("Dv::diskIns - No partitions - good to go son!");
|
||||
#endif
|
||||
setState(Volume::State_Idle);
|
||||
} else {
|
||||
#ifdef PARTITION_DEBUG
|
||||
SLOGD("Dv::diskIns - waiting for %d pending partitions", mPendingPartCount);
|
||||
#endif
|
||||
setState(Volume::State_Pending);
|
||||
}
|
||||
}
|
||||
|
||||
void DirectVolume::handlePartitionAdded(const char *devpath, NetlinkEvent *evt) {
|
||||
int major = atoi(evt->findParam("MAJOR"));
|
||||
int minor = atoi(evt->findParam("MINOR"));
|
||||
|
||||
int part_num;
|
||||
|
||||
const char *tmp = evt->findParam("PARTN");
|
||||
|
||||
if (tmp) {
|
||||
part_num = atoi(tmp);
|
||||
} else {
|
||||
SLOGW("Kernel block uevent missing 'PARTN'");
|
||||
part_num = 1;
|
||||
}
|
||||
|
||||
if (part_num > MAX_PARTITIONS || part_num < 1) {
|
||||
SLOGE("Invalid 'PARTN' value");
|
||||
return;
|
||||
}
|
||||
|
||||
if (part_num > mDiskNumParts) {
|
||||
mDiskNumParts = part_num;
|
||||
}
|
||||
|
||||
if (major != mDiskMajor) {
|
||||
SLOGE("Partition '%s' has a different major than its disk!", devpath);
|
||||
return;
|
||||
}
|
||||
#ifdef PARTITION_DEBUG
|
||||
SLOGD("Dv:partAdd: part_num = %d, minor = %d\n", part_num, minor);
|
||||
#endif
|
||||
if (part_num >= MAX_PARTITIONS) {
|
||||
SLOGE("Dv:partAdd: ignoring part_num = %d (max: %d)\n", part_num, MAX_PARTITIONS-1);
|
||||
} else {
|
||||
if ((mPartMinors[part_num - 1] == -1) && mPendingPartCount)
|
||||
mPendingPartCount--;
|
||||
mPartMinors[part_num -1] = minor;
|
||||
}
|
||||
|
||||
if (!mPendingPartCount) {
|
||||
#ifdef PARTITION_DEBUG
|
||||
SLOGD("Dv:partAdd: Got all partitions - ready to rock!");
|
||||
#endif
|
||||
if (getState() != Volume::State_Formatting) {
|
||||
setState(Volume::State_Idle);
|
||||
if (mRetryMount == true) {
|
||||
mRetryMount = false;
|
||||
mountVol();
|
||||
}
|
||||
}
|
||||
} else {
|
||||
#ifdef PARTITION_DEBUG
|
||||
SLOGD("Dv:partAdd: pending %d disk", mPendingPartCount);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
void DirectVolume::handleDiskChanged(const char * /*devpath*/,
|
||||
NetlinkEvent *evt) {
|
||||
int major = atoi(evt->findParam("MAJOR"));
|
||||
int minor = atoi(evt->findParam("MINOR"));
|
||||
|
||||
if ((major != mDiskMajor) || (minor != mDiskMinor)) {
|
||||
return;
|
||||
}
|
||||
|
||||
SLOGI("Volume %s disk has changed", getLabel());
|
||||
const char *tmp = evt->findParam("NPARTS");
|
||||
if (tmp) {
|
||||
mDiskNumParts = atoi(tmp);
|
||||
} else {
|
||||
SLOGW("Kernel block uevent missing 'NPARTS'");
|
||||
mDiskNumParts = 1;
|
||||
}
|
||||
|
||||
mPendingPartCount = mDiskNumParts;
|
||||
for (int i = 0; i < MAX_PARTITIONS; i++)
|
||||
mPartMinors[i] = -1;
|
||||
|
||||
if (getState() != Volume::State_Formatting) {
|
||||
if (mDiskNumParts == 0) {
|
||||
setState(Volume::State_Idle);
|
||||
} else {
|
||||
setState(Volume::State_Pending);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void DirectVolume::handlePartitionChanged(const char * /*devpath*/,
|
||||
NetlinkEvent *evt) {
|
||||
int major = atoi(evt->findParam("MAJOR"));
|
||||
int minor = atoi(evt->findParam("MINOR"));
|
||||
SLOGD("Volume %s %s partition %d:%d changed\n", getLabel(), getMountpoint(), major, minor);
|
||||
}
|
||||
|
||||
void DirectVolume::handleDiskRemoved(const char * /*devpath*/,
|
||||
NetlinkEvent *evt) {
|
||||
int major = atoi(evt->findParam("MAJOR"));
|
||||
int minor = atoi(evt->findParam("MINOR"));
|
||||
char msg[255];
|
||||
bool enabled;
|
||||
|
||||
SLOGD("Volume %s %s disk %d:%d removed\n", getLabel(), getMountpoint(), major, minor);
|
||||
if ((dev_t) MKDEV(major, minor) == mCurrentlyMountedKdev) {
|
||||
/*
|
||||
* Yikes, our mounted disk is going away!
|
||||
*/
|
||||
|
||||
doUnmount(major, minor);
|
||||
} else if (mVm->shareEnabled(getLabel(), "ums", &enabled) == 0 && enabled) {
|
||||
mVm->unshareVolume(getLabel(), "ums");
|
||||
}
|
||||
|
||||
snprintf(msg, sizeof(msg), "Volume %s %s disk removed (%d:%d)",
|
||||
getLabel(), getFuseMountpoint(), major, minor);
|
||||
mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskRemoved,
|
||||
msg, false);
|
||||
setState(Volume::State_NoMedia);
|
||||
}
|
||||
|
||||
void DirectVolume::handlePartitionRemoved(const char * /*devpath*/,
|
||||
NetlinkEvent *evt) {
|
||||
int major = atoi(evt->findParam("MAJOR"));
|
||||
int minor = atoi(evt->findParam("MINOR"));
|
||||
char msg[255];
|
||||
int state;
|
||||
|
||||
SLOGD("Volume %s %s partition %d:%d removed\n", getLabel(), getMountpoint(), major, minor);
|
||||
|
||||
/*
|
||||
* The framework doesn't need to get notified of
|
||||
* partition removal unless it's mounted. Otherwise
|
||||
* the removal notification will be sent on the Disk
|
||||
* itself
|
||||
*/
|
||||
state = getState();
|
||||
if (state != Volume::State_Mounted && state != Volume::State_Shared) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ((dev_t) MKDEV(major, minor) == mCurrentlyMountedKdev) {
|
||||
/*
|
||||
* Yikes, our mounted partition is going away!
|
||||
*/
|
||||
doUnmount(major, minor);
|
||||
} else if (state == Volume::State_Shared) {
|
||||
/* removed during mass storage */
|
||||
snprintf(msg, sizeof(msg), "Volume %s bad removal (%d:%d)",
|
||||
getLabel(), major, minor);
|
||||
mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeBadRemoval,
|
||||
msg, false);
|
||||
|
||||
if (mVm->unshareVolume(getLabel(), "ums")) {
|
||||
SLOGE("Failed to unshare volume on bad removal (%s)",
|
||||
strerror(errno));
|
||||
} else {
|
||||
SLOGD("Crisis averted");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void DirectVolume::doUnmount(int major, int minor) {
|
||||
char msg[255];
|
||||
bool providesAsec = (getFlags() & VOL_PROVIDES_ASEC) != 0;
|
||||
if (providesAsec && mVm->cleanupAsec(this, true)) {
|
||||
SLOGE("Failed to cleanup ASEC - unmount will probably fail!");
|
||||
}
|
||||
|
||||
snprintf(msg, sizeof(msg), "Volume %s %s bad removal (%d:%d)",
|
||||
getLabel(), getFuseMountpoint(), major, minor);
|
||||
mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeBadRemoval,
|
||||
msg, false);
|
||||
|
||||
if (Volume::unmountVol(true, false)) {
|
||||
SLOGE("Failed to unmount volume on bad removal (%s)",
|
||||
strerror(errno));
|
||||
// XXX: At this point we're screwed for now
|
||||
} else {
|
||||
SLOGD("Crisis averted");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Called from base to get a list of devicenodes for mounting
|
||||
*/
|
||||
int DirectVolume::getDeviceNodes(dev_t *devs, int max) {
|
||||
|
||||
if (mPartIdx == -1) {
|
||||
// If the disk has no partitions, try the disk itself
|
||||
if (!mDiskNumParts) {
|
||||
devs[0] = MKDEV(mDiskMajor, mDiskMinor);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int i;
|
||||
for (i = 0; i < mDiskNumParts; i++) {
|
||||
if (i == max)
|
||||
break;
|
||||
devs[i] = MKDEV(mDiskMajor, mPartMinors[i]);
|
||||
}
|
||||
return mDiskNumParts;
|
||||
}
|
||||
devs[0] = MKDEV(mDiskMajor, mPartMinors[mPartIdx -1]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Called from base to update device info,
|
||||
* e.g. When setting up an dm-crypt mapping for the sd card.
|
||||
*/
|
||||
int DirectVolume::updateDeviceInfo(char *new_path, int new_major, int new_minor)
|
||||
{
|
||||
PathCollection::iterator it;
|
||||
|
||||
if (mPartIdx == -1) {
|
||||
SLOGE("Can only change device info on a partition\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
* This is to change the sysfs path associated with a partition, in particular,
|
||||
* for an internal SD card partition that is encrypted. Thus, the list is
|
||||
* expected to be only 1 entry long. Check that and bail if not.
|
||||
*/
|
||||
if (mPaths->size() != 1) {
|
||||
SLOGE("Cannot change path if there are more than one for a volume\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
it = mPaths->begin();
|
||||
delete *it; /* Free the string storage */
|
||||
mPaths->erase(it); /* Remove it from the list */
|
||||
addPath(new_path); /* Put the new path on the list */
|
||||
|
||||
/* Save away original info so we can restore it when doing factory reset.
|
||||
* Then, when doing the format, it will format the original device in the
|
||||
* clear, otherwise it just formats the encrypted device which is not
|
||||
* readable when the device boots unencrypted after the reset.
|
||||
*/
|
||||
mOrigDiskMajor = mDiskMajor;
|
||||
mOrigDiskMinor = mDiskMinor;
|
||||
mOrigPartIdx = mPartIdx;
|
||||
memcpy(mOrigPartMinors, mPartMinors, sizeof(mPartMinors));
|
||||
|
||||
mDiskMajor = new_major;
|
||||
mDiskMinor = new_minor;
|
||||
/* Ugh, virual block devices don't use minor 0 for whole disk and minor > 0 for
|
||||
* partition number. They don't have partitions, they are just virtual block
|
||||
* devices, and minor number 0 is the first dm-crypt device. Luckily the first
|
||||
* dm-crypt device is for the userdata partition, which gets minor number 0, and
|
||||
* it is not managed by vold. So the next device is minor number one, which we
|
||||
* will call partition one.
|
||||
*/
|
||||
mPartIdx = new_minor;
|
||||
mPartMinors[new_minor-1] = new_minor;
|
||||
|
||||
mIsDecrypted = 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Called from base to revert device info to the way it was before a
|
||||
* crypto mapping was created for it.
|
||||
*/
|
||||
void DirectVolume::revertDeviceInfo(void)
|
||||
{
|
||||
if (mIsDecrypted) {
|
||||
mDiskMajor = mOrigDiskMajor;
|
||||
mDiskMinor = mOrigDiskMinor;
|
||||
mPartIdx = mOrigPartIdx;
|
||||
memcpy(mPartMinors, mOrigPartMinors, sizeof(mPartMinors));
|
||||
|
||||
mIsDecrypted = 0;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* Called from base to give cryptfs all the info it needs to encrypt eligible volumes
|
||||
*/
|
||||
int DirectVolume::getVolInfo(struct volume_info *v)
|
||||
{
|
||||
strcpy(v->label, mLabel);
|
||||
strcpy(v->mnt_point, mMountpoint);
|
||||
v->flags = getFlags();
|
||||
/* Other fields of struct volume_info are filled in by the caller or cryptfs.c */
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,93 +0,0 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef _DEVICEVOLUME_H
|
||||
#define _DEVICEVOLUME_H
|
||||
|
||||
#include <utils/List.h>
|
||||
|
||||
#include "Volume.h"
|
||||
|
||||
class PathInfo {
|
||||
public:
|
||||
PathInfo(const char *pattern);
|
||||
~PathInfo();
|
||||
bool match(const char *path);
|
||||
private:
|
||||
bool warned;
|
||||
char *pattern;
|
||||
enum PatternType { prefix, wildcard };
|
||||
PatternType patternType;
|
||||
};
|
||||
|
||||
typedef android::List<PathInfo *> PathCollection;
|
||||
|
||||
class DirectVolume : public Volume {
|
||||
public:
|
||||
static const int MAX_PARTITIONS = 32;
|
||||
protected:
|
||||
const char* mMountpoint;
|
||||
const char* mFuseMountpoint;
|
||||
|
||||
PathCollection *mPaths;
|
||||
int mDiskMajor;
|
||||
int mDiskMinor;
|
||||
int mPartMinors[MAX_PARTITIONS];
|
||||
int mOrigDiskMajor;
|
||||
int mOrigDiskMinor;
|
||||
int mOrigPartMinors[MAX_PARTITIONS];
|
||||
int mDiskNumParts;
|
||||
int mPendingPartCount;
|
||||
int mIsDecrypted;
|
||||
|
||||
public:
|
||||
DirectVolume(VolumeManager *vm, const fstab_rec* rec, int flags);
|
||||
virtual ~DirectVolume();
|
||||
|
||||
int addPath(const char *path);
|
||||
|
||||
const char *getMountpoint() { return mMountpoint; }
|
||||
const char *getFuseMountpoint() { return mFuseMountpoint; }
|
||||
|
||||
int handleBlockEvent(NetlinkEvent *evt);
|
||||
dev_t getDiskDevice();
|
||||
dev_t getShareDevice();
|
||||
void handleVolumeShared();
|
||||
void handleVolumeUnshared();
|
||||
int getVolInfo(struct volume_info *v);
|
||||
|
||||
protected:
|
||||
int getDeviceNodes(dev_t *devs, int max);
|
||||
int updateDeviceInfo(char *new_path, int new_major, int new_minor);
|
||||
virtual void revertDeviceInfo(void);
|
||||
int isDecrypted() { return mIsDecrypted; }
|
||||
|
||||
private:
|
||||
void handleDiskAdded(const char *devpath, NetlinkEvent *evt);
|
||||
void handleDiskRemoved(const char *devpath, NetlinkEvent *evt);
|
||||
void handleDiskChanged(const char *devpath, NetlinkEvent *evt);
|
||||
void handlePartitionAdded(const char *devpath, NetlinkEvent *evt);
|
||||
void handlePartitionRemoved(const char *devpath, NetlinkEvent *evt);
|
||||
void handlePartitionChanged(const char *devpath, NetlinkEvent *evt);
|
||||
|
||||
int doMountVfat(const char *deviceNode, const char *mountPoint);
|
||||
void doUnmount(int major, int minor);
|
||||
|
||||
};
|
||||
|
||||
typedef android::List<DirectVolume *> DirectVolumeCollection;
|
||||
|
||||
#endif
|
||||
@ -1,707 +0,0 @@
|
||||
/*
|
||||
* 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 <mntent.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 "Process.h"
|
||||
#include "cryptfs.h"
|
||||
#include "sehandle.h"
|
||||
|
||||
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/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";
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
Volume::~Volume() {
|
||||
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);
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
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) {
|
||||
char *secontext = NULL;
|
||||
mode_t mode = 0660 | S_IFBLK;
|
||||
dev_t dev = (major << 8) | minor;
|
||||
int rc;
|
||||
if (sehandle) {
|
||||
rc = selabel_lookup(sehandle, &secontext, path, S_IFBLK);
|
||||
if (rc == 0)
|
||||
setfscreatecon(secontext);
|
||||
}
|
||||
if (mknod(path, mode, dev) < 0) {
|
||||
if (errno != EEXIST) {
|
||||
int sverrno = errno;
|
||||
if (secontext) {
|
||||
freecon(secontext);
|
||||
setfscreatecon(NULL);
|
||||
}
|
||||
errno = sverrno;
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
if (secontext) {
|
||||
setfscreatecon(NULL);
|
||||
freecon(secontext);
|
||||
}
|
||||
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];
|
||||
dev_t diskNode = getDiskDevice();
|
||||
dev_t partNode =
|
||||
MKDEV(MAJOR(diskNode),
|
||||
MINOR(diskNode) + (formatEntireDevice ? 0 : mPartIdx));
|
||||
|
||||
setState(Volume::State_Formatting);
|
||||
|
||||
int ret = -1;
|
||||
// Only initialize the MBR if we are formatting the entire device
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
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)) {
|
||||
SLOGE("Failed to format (%s)", strerror(errno));
|
||||
goto err;
|
||||
}
|
||||
|
||||
ret = 0;
|
||||
|
||||
err:
|
||||
setState(Volume::State_Idle);
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool Volume::isMountpointMounted(const char *path) {
|
||||
FILE *fp = setmntent("/proc/mounts", "r");
|
||||
if (fp == NULL) {
|
||||
SLOGE("Error opening /proc/mounts (%s)", strerror(errno));
|
||||
return false;
|
||||
}
|
||||
|
||||
bool found_path = false;
|
||||
mntent* mentry;
|
||||
while ((mentry = getmntent(fp)) != NULL) {
|
||||
if (strcmp(mentry->mnt_dir, path) == 0) {
|
||||
found_path = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
endmntent(fp);
|
||||
return found_path;
|
||||
}
|
||||
|
||||
int Volume::mountVol() {
|
||||
dev_t deviceNodes[4];
|
||||
int n, i;
|
||||
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];
|
||||
|
||||
property_get("vold.decrypt", decrypt_state, "");
|
||||
property_get("vold.encrypt_progress", encrypt_progress, "");
|
||||
|
||||
/* Don't try to mount the volumes if we have not yet entered the disk password
|
||||
* or are in the process of encrypting.
|
||||
*/
|
||||
if ((getState() == Volume::State_NoMedia) ||
|
||||
((!strcmp(decrypt_state, "1") || encrypt_progress[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;
|
||||
}
|
||||
|
||||
/* 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, "");
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < n; i++) {
|
||||
char devicePath[255];
|
||||
|
||||
sprintf(devicePath, "/dev/block/vold/%d:%d", major(deviceNodes[i]),
|
||||
minor(deviceNodes[i]));
|
||||
|
||||
SLOGI("%s being considered for volume %s\n", devicePath, getLabel());
|
||||
|
||||
errno = 0;
|
||||
setState(Volume::State_Checking);
|
||||
|
||||
if (Fat::check(devicePath)) {
|
||||
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;
|
||||
|
||||
if (Fat::doMount(devicePath, getMountpoint(), false, false, false,
|
||||
AID_MEDIA_RW, AID_MEDIA_RW, 0007, true)) {
|
||||
SLOGE("%s failed to mount via VFAT (%s)\n", devicePath, strerror(errno));
|
||||
continue;
|
||||
}
|
||||
|
||||
extractMetadata(devicePath);
|
||||
|
||||
if (providesAsec && 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];
|
||||
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];
|
||||
|
||||
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 (fs_prepare_dir(secure_path, 0770, AID_MEDIA_RW, 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;
|
||||
}
|
||||
|
||||
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);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int signal = 0;
|
||||
|
||||
if (force) {
|
||||
if (retries == 1) {
|
||||
signal = SIGKILL;
|
||||
} else if (retries == 2) {
|
||||
signal = SIGTERM;
|
||||
}
|
||||
}
|
||||
|
||||
SLOGW("Failed to unmount %s (%s, retries %d, signal %d)",
|
||||
path, strerror(errno), retries, signal);
|
||||
|
||||
Process::killProcessesWithOpenFiles(path, signal);
|
||||
usleep(1000*1000);
|
||||
}
|
||||
errno = EBUSY;
|
||||
SLOGE("Giving up on unmount %s (%s)", path, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
int Volume::unmountVol(bool force, bool revert) {
|
||||
int flags = getFlags();
|
||||
bool providesAsec = (flags & VOL_PROVIDES_ASEC) != 0;
|
||||
|
||||
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 && doUnmount(Volume::SEC_ASECDIR_EXT, force) != 0) {
|
||||
SLOGE("Failed to unmount secure area on %s (%s)", getMountpoint(), strerror(errno));
|
||||
goto out_mounted;
|
||||
}
|
||||
|
||||
/* 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 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) {
|
||||
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;
|
||||
}
|
||||
@ -1,115 +0,0 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef _VOLUME_H
|
||||
#define _VOLUME_H
|
||||
|
||||
#include <utils/List.h>
|
||||
#include <fs_mgr.h>
|
||||
|
||||
class NetlinkEvent;
|
||||
class VolumeManager;
|
||||
|
||||
class Volume {
|
||||
private:
|
||||
int mState;
|
||||
int mFlags;
|
||||
|
||||
public:
|
||||
static const int State_Init = -1;
|
||||
static const int State_NoMedia = 0;
|
||||
static const int State_Idle = 1;
|
||||
static const int State_Pending = 2;
|
||||
static const int State_Checking = 3;
|
||||
static const int State_Mounted = 4;
|
||||
static const int State_Unmounting = 5;
|
||||
static const int State_Formatting = 6;
|
||||
static const int State_Shared = 7;
|
||||
static const int State_SharedMnt = 8;
|
||||
|
||||
static const char *MEDIA_DIR;
|
||||
static const char *FUSE_DIR;
|
||||
static const char *SEC_ASECDIR_EXT;
|
||||
static const char *SEC_ASECDIR_INT;
|
||||
static const char *ASECDIR;
|
||||
static const char *LOOPDIR;
|
||||
static const char *BLKID_PATH;
|
||||
|
||||
protected:
|
||||
char* mLabel;
|
||||
char* mUuid;
|
||||
char* mUserLabel;
|
||||
VolumeManager *mVm;
|
||||
bool mDebug;
|
||||
int mPartIdx;
|
||||
int mOrigPartIdx;
|
||||
bool mRetryMount;
|
||||
|
||||
/*
|
||||
* The major/minor tuple of the currently mounted filesystem.
|
||||
*/
|
||||
dev_t mCurrentlyMountedKdev;
|
||||
|
||||
public:
|
||||
Volume(VolumeManager *vm, const fstab_rec* rec, int flags);
|
||||
virtual ~Volume();
|
||||
|
||||
int mountVol();
|
||||
int unmountVol(bool force, bool revert);
|
||||
int formatVol(bool wipe);
|
||||
|
||||
const char* getLabel() { return mLabel; }
|
||||
const char* getUuid() { return mUuid; }
|
||||
const char* getUserLabel() { return mUserLabel; }
|
||||
int getState() { return mState; }
|
||||
int getFlags() { return mFlags; };
|
||||
|
||||
/* Mountpoint of the raw volume */
|
||||
virtual const char *getMountpoint() = 0;
|
||||
virtual const char *getFuseMountpoint() = 0;
|
||||
|
||||
virtual int handleBlockEvent(NetlinkEvent *evt);
|
||||
virtual dev_t getDiskDevice();
|
||||
virtual dev_t getShareDevice();
|
||||
virtual void handleVolumeShared();
|
||||
virtual void handleVolumeUnshared();
|
||||
|
||||
void setDebug(bool enable);
|
||||
virtual int getVolInfo(struct volume_info *v) = 0;
|
||||
|
||||
protected:
|
||||
void setUuid(const char* uuid);
|
||||
void setUserLabel(const char* userLabel);
|
||||
void setState(int state);
|
||||
|
||||
virtual int getDeviceNodes(dev_t *devs, int max) = 0;
|
||||
virtual int updateDeviceInfo(char *new_path, int new_major, int new_minor) = 0;
|
||||
virtual void revertDeviceInfo(void) = 0;
|
||||
virtual int isDecrypted(void) = 0;
|
||||
|
||||
int createDeviceNode(const char *path, int major, int minor);
|
||||
|
||||
private:
|
||||
int initializeMbr(const char *deviceNode);
|
||||
bool isMountpointMounted(const char *path);
|
||||
int mountAsecExternal();
|
||||
int doUnmount(const char *path, bool force);
|
||||
int extractMetadata(const char* devicePath);
|
||||
};
|
||||
|
||||
typedef android::List<Volume *> VolumeCollection;
|
||||
|
||||
#endif
|
||||
Loading…
Reference in new issue