Merge changes Ic3993c1f,I06645bb4 am: ac34e9aa3e am: b62afed286 am: 54d05de798
Change-Id: Ib122e011bb7be162b76b94a31885863d2aff6d1e
diff --git a/Android.bp b/Android.bp
index dae0859..a420078 100644
--- a/Android.bp
+++ b/Android.bp
@@ -28,6 +28,7 @@
name: "vold_default_libs",
static_libs: [
+ "libasync_safe",
"libavb",
"libbootloader_message",
"libdm",
@@ -240,6 +241,7 @@
"libhidlbase",
"libkeymaster4support",
"libkeymaster4_1support",
+ "libutils",
],
}
@@ -276,6 +278,7 @@
srcs: [
"binder/android/os/IVold.aidl",
"binder/android/os/IVoldListener.aidl",
+ "binder/android/os/IVoldMountCallback.aidl",
"binder/android/os/IVoldTaskListener.aidl",
],
path: "binder",
diff --git a/FsCrypt.cpp b/FsCrypt.cpp
index 21495be..0619fba 100644
--- a/FsCrypt.cpp
+++ b/FsCrypt.cpp
@@ -62,8 +62,11 @@
using android::base::StringPrintf;
using android::fs_mgr::GetEntryForMountPoint;
using android::vold::BuildDataPath;
+using android::vold::IsFilesystemSupported;
using android::vold::kEmptyAuthentication;
using android::vold::KeyBuffer;
+using android::vold::SetQuotaInherit;
+using android::vold::SetQuotaProjectId;
using android::vold::writeStringToFile;
using namespace android::fscrypt;
@@ -795,6 +798,14 @@
if (!prepare_dir(vendor_ce_path, 0771, AID_ROOT, AID_ROOT)) return false;
}
if (!prepare_dir(media_ce_path, 0770, AID_MEDIA_RW, AID_MEDIA_RW)) return false;
+ // Setup quota project ID and inheritance policy
+ if (!IsFilesystemSupported("sdcardfs")) {
+ if (SetQuotaInherit(media_ce_path) != 0) return false;
+ if (SetQuotaProjectId(media_ce_path, multiuser_get_uid(user_id, AID_MEDIA_RW)) != 0) {
+ return false;
+ }
+ }
+
if (!prepare_dir(user_ce_path, 0771, AID_SYSTEM, AID_SYSTEM)) return false;
if (fscrypt_is_native()) {
diff --git a/Keymaster.h b/Keymaster.h
index ea102f5..4a9ed02 100644
--- a/Keymaster.h
+++ b/Keymaster.h
@@ -133,7 +133,7 @@
void earlyBootEnded();
private:
- std::unique_ptr<KmDevice> mDevice;
+ sp<KmDevice> mDevice;
DISALLOW_COPY_AND_ASSIGN(Keymaster);
static bool hmacKeyGenerated;
};
diff --git a/TEST_MAPPING b/TEST_MAPPING
new file mode 100644
index 0000000..e1f3653
--- /dev/null
+++ b/TEST_MAPPING
@@ -0,0 +1,10 @@
+{
+ "presubmit": [
+ {
+ "name": "FuseDaemonHostTest"
+ },
+ {
+ "name": "AdoptableHostTest"
+ }
+ ]
+}
diff --git a/Utils.cpp b/Utils.cpp
index 1616d80..6a67071 100644
--- a/Utils.cpp
+++ b/Utils.cpp
@@ -33,20 +33,23 @@
#include <dirent.h>
#include <fcntl.h>
#include <linux/fs.h>
+#include <linux/posix_acl.h>
+#include <linux/posix_acl_xattr.h>
#include <mntent.h>
#include <stdio.h>
#include <stdlib.h>
-#include <unistd.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
#include <sys/wait.h>
+#include <sys/xattr.h>
#include <unistd.h>
#include <list>
#include <mutex>
+#include <regex>
#include <thread>
#ifndef UMOUNT_NOFOLLOW
@@ -54,7 +57,9 @@
#endif
using namespace std::chrono_literals;
+using android::base::EndsWith;
using android::base::ReadFileToString;
+using android::base::StartsWith;
using android::base::StringPrintf;
namespace android {
@@ -72,6 +77,11 @@
static const char* kProcFilesystems = "/proc/filesystems";
+static const char* kAndroidDir = "/Android/";
+static const char* kAppDataDir = "/Android/data/";
+static const char* kAppMediaDir = "/Android/media/";
+static const char* kAppObbDir = "/Android/obb/";
+
// Lock used to protect process-level SELinux changes from racing with each
// other between multiple threads.
static std::mutex kSecurityLock;
@@ -114,6 +124,204 @@
}
}
+// Sets a default ACL where the owner and group can read/write/execute.
+// Other users aren't allowed anything.
+int SetDefault770Acl(const std::string& path, uid_t uid, gid_t gid) {
+ if (IsFilesystemSupported("sdcardfs")) {
+ // sdcardfs magically takes care of this
+ return OK;
+ }
+
+ static constexpr size_t size =
+ sizeof(posix_acl_xattr_header) + 3 * sizeof(posix_acl_xattr_entry);
+ auto buf = std::make_unique<uint8_t[]>(size);
+
+ posix_acl_xattr_header* acl_header = reinterpret_cast<posix_acl_xattr_header*>(buf.get());
+ acl_header->a_version = POSIX_ACL_XATTR_VERSION;
+
+ posix_acl_xattr_entry* entry =
+ reinterpret_cast<posix_acl_xattr_entry*>(buf.get() + sizeof(posix_acl_xattr_header));
+
+ entry[0].e_tag = ACL_USER_OBJ;
+ entry[0].e_perm = ACL_READ | ACL_WRITE | ACL_EXECUTE;
+ entry[0].e_id = uid;
+
+ entry[1].e_tag = ACL_GROUP_OBJ;
+ entry[1].e_perm = ACL_READ | ACL_WRITE | ACL_EXECUTE;
+ entry[1].e_id = gid;
+
+ entry[2].e_tag = ACL_OTHER;
+ entry[2].e_perm = 0;
+ entry[2].e_id = 0;
+
+ int ret = setxattr(path.c_str(), XATTR_NAME_POSIX_ACL_DEFAULT, acl_header, size, 0);
+
+ if (ret != 0) {
+ PLOG(ERROR) << "Failed to set default ACL on " << path;
+ }
+
+ return ret;
+}
+
+int SetQuotaInherit(const std::string& path) {
+ unsigned long flags;
+
+ android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_CLOEXEC)));
+ if (fd == -1) {
+ PLOG(ERROR) << "Failed to open " << path << " to set project id inheritance.";
+ return -1;
+ }
+
+ int ret = ioctl(fd, FS_IOC_GETFLAGS, &flags);
+ if (ret == -1) {
+ PLOG(ERROR) << "Failed to get flags for " << path << " to set project id inheritance.";
+ return ret;
+ }
+
+ flags |= FS_PROJINHERIT_FL;
+
+ ret = ioctl(fd, FS_IOC_SETFLAGS, &flags);
+ if (ret == -1) {
+ PLOG(ERROR) << "Failed to set flags for " << path << " to set project id inheritance.";
+ return ret;
+ }
+
+ return 0;
+}
+
+int SetQuotaProjectId(const std::string& path, long projectId) {
+ struct fsxattr fsx;
+
+ android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_CLOEXEC)));
+ if (fd == -1) {
+ PLOG(ERROR) << "Failed to open " << path << " to set project id.";
+ return -1;
+ }
+
+ int ret = ioctl(fd, FS_IOC_FSGETXATTR, &fsx);
+ if (ret == -1) {
+ PLOG(ERROR) << "Failed to get extended attributes for " << path << " to get project id.";
+ return ret;
+ }
+
+ fsx.fsx_projid = projectId;
+ return ioctl(fd, FS_IOC_FSSETXATTR, &fsx);
+}
+
+int PrepareDirWithProjectId(const std::string& path, mode_t mode, uid_t uid, gid_t gid,
+ long projectId) {
+ int ret = fs_prepare_dir(path.c_str(), mode, uid, gid);
+
+ if (ret != 0) {
+ return ret;
+ }
+
+ if (!IsFilesystemSupported("sdcardfs")) {
+ ret = SetQuotaProjectId(path, projectId);
+ }
+
+ return ret;
+}
+
+int PrepareAppDirFromRoot(const std::string& path, const std::string& root, int appUid) {
+ long projectId;
+ size_t pos;
+ int ret = 0;
+
+ // Make sure the Android/ directories exist and are setup correctly
+ ret = PrepareAndroidDirs(root);
+ if (ret != 0) {
+ LOG(ERROR) << "Failed to prepare Android/ directories.";
+ return ret;
+ }
+
+ // Now create the application-specific subdir(s)
+ // path is something like /data/media/0/Android/data/com.foo/files
+ // First, chop off the volume root, eg /data/media/0
+ std::string pathFromRoot = path.substr(root.length());
+
+ uid_t uid = appUid;
+ gid_t gid = AID_MEDIA_RW;
+ std::string appDir;
+
+ // Check that the next part matches one of the allowed Android/ dirs
+ if (StartsWith(pathFromRoot, kAppDataDir)) {
+ appDir = kAppDataDir;
+ if (!IsFilesystemSupported("sdcardfs")) {
+ gid = AID_EXT_DATA_RW;
+ }
+ } else if (StartsWith(pathFromRoot, kAppMediaDir)) {
+ appDir = kAppMediaDir;
+ if (!IsFilesystemSupported("sdcardfs")) {
+ gid = AID_MEDIA_RW;
+ }
+ } else if (StartsWith(pathFromRoot, kAppMediaDir)) {
+ appDir = kAppObbDir;
+ if (!IsFilesystemSupported("sdcardfs")) {
+ gid = AID_EXT_OBB_RW;
+ }
+ } else {
+ LOG(ERROR) << "Invalid application directory: " << path;
+ return -EINVAL;
+ }
+
+ // mode = 770, plus sticky bit on directory to inherit GID when apps
+ // create subdirs
+ mode_t mode = S_IRWXU | S_IRWXG | S_ISGID;
+ // the project ID for application-specific directories is directly
+ // derived from their uid
+
+ // Chop off the generic application-specific part, eg /Android/data/
+ // this leaves us with something like com.foo/files/
+ std::string leftToCreate = pathFromRoot.substr(appDir.length());
+ if (!EndsWith(leftToCreate, "/")) {
+ leftToCreate += "/";
+ }
+ std::string pathToCreate = root + appDir;
+ int depth = 0;
+ bool withinCache = false;
+ while ((pos = leftToCreate.find('/')) != std::string::npos) {
+ std::string component = leftToCreate.substr(0, pos + 1);
+ leftToCreate = leftToCreate.erase(0, pos + 1);
+ pathToCreate = pathToCreate + component;
+
+ if (appDir == kAppDataDir && depth == 1 && component == "cache/") {
+ // All dirs use the "app" project ID, except for the cache dirs in
+ // Android/data, eg Android/data/com.foo/cache
+ // Note that this "sticks" - eg subdirs of this dir need the same
+ // project ID.
+ withinCache = true;
+ }
+ if (withinCache) {
+ projectId = uid - AID_APP_START + AID_CACHE_GID_START;
+ } else {
+ projectId = uid - AID_APP_START + AID_EXT_GID_START;
+ }
+ ret = PrepareDirWithProjectId(pathToCreate, mode, uid, gid, projectId);
+ if (ret != 0) {
+ return ret;
+ }
+
+ if (depth == 0) {
+ // Set the default ACL on the top-level application-specific directories,
+ // to ensure that even if applications run with a umask of 0077,
+ // new directories within these directories will allow the GID
+ // specified here to write; this is necessary for apps like
+ // installers and MTP, that require access here.
+ //
+ // See man (5) acl for more details.
+ ret = SetDefault770Acl(pathToCreate, uid, gid);
+ if (ret != 0) {
+ return ret;
+ }
+ }
+
+ depth++;
+ }
+
+ return OK;
+}
+
status_t PrepareDir(const std::string& path, mode_t mode, uid_t uid, gid_t gid) {
std::lock_guard<std::mutex> lock(kSecurityLock);
const char* cpath = path.c_str();
@@ -165,7 +373,7 @@
if (!umount2(cpath, UMOUNT_NOFOLLOW) || errno == EINVAL || errno == ENOENT) {
return OK;
}
-
+ PLOG(INFO) << "ForceUnmount failed";
return -errno;
}
@@ -985,5 +1193,175 @@
return true;
}
+status_t MountUserFuse(userid_t user_id, const std::string& absolute_lower_path,
+ const std::string& relative_upper_path, android::base::unique_fd* fuse_fd) {
+ std::string pre_fuse_path(StringPrintf("/mnt/user/%d", user_id));
+ std::string fuse_path(
+ StringPrintf("%s/%s", pre_fuse_path.c_str(), relative_upper_path.c_str()));
+
+ std::string pre_pass_through_path(StringPrintf("/mnt/pass_through/%d", user_id));
+ std::string pass_through_path(
+ StringPrintf("%s/%s", pre_pass_through_path.c_str(), relative_upper_path.c_str()));
+
+ // Ensure that /mnt/user is 0700. With FUSE, apps don't need access to /mnt/user paths directly.
+ // Without FUSE however, apps need /mnt/user access so /mnt/user in init.rc is 0755 until here
+ auto result = PrepareDir("/mnt/user", 0750, AID_ROOT, AID_MEDIA_RW);
+ if (result != android::OK) {
+ PLOG(ERROR) << "Failed to prepare directory /mnt/user";
+ return -1;
+ }
+
+ // Shell is neither AID_ROOT nor AID_EVERYBODY. Since it equally needs 'execute' access to
+ // /mnt/user/0 to 'adb shell ls /sdcard' for instance, we set the uid bit of /mnt/user/0 to
+ // AID_SHELL. This gives shell access along with apps running as group everybody (user 0 apps)
+ // These bits should be consistent with what is set in zygote in
+ // com_android_internal_os_Zygote#MountEmulatedStorage on volume bind mount during app fork
+ result = PrepareDir(pre_fuse_path, 0710, user_id ? AID_ROOT : AID_SHELL,
+ multiuser_get_uid(user_id, AID_EVERYBODY));
+ if (result != android::OK) {
+ PLOG(ERROR) << "Failed to prepare directory " << pre_fuse_path;
+ return -1;
+ }
+
+ result = PrepareDir(fuse_path, 0700, AID_ROOT, AID_ROOT);
+ if (result != android::OK) {
+ PLOG(ERROR) << "Failed to prepare directory " << fuse_path;
+ return -1;
+ }
+
+ result = PrepareDir(pre_pass_through_path, 0710, AID_ROOT, AID_MEDIA_RW);
+ if (result != android::OK) {
+ PLOG(ERROR) << "Failed to prepare directory " << pre_pass_through_path;
+ return -1;
+ }
+
+ result = PrepareDir(pass_through_path, 0710, AID_ROOT, AID_MEDIA_RW);
+ if (result != android::OK) {
+ PLOG(ERROR) << "Failed to prepare directory " << pass_through_path;
+ return -1;
+ }
+
+ if (relative_upper_path == "emulated") {
+ std::string linkpath(StringPrintf("/mnt/user/%d/self", user_id));
+ result = PrepareDir(linkpath, 0755, AID_ROOT, AID_ROOT);
+ if (result != android::OK) {
+ PLOG(ERROR) << "Failed to prepare directory " << linkpath;
+ return -1;
+ }
+ linkpath += "/primary";
+ Symlink("/storage/emulated/" + std::to_string(user_id), linkpath);
+
+ std::string pass_through_linkpath(StringPrintf("/mnt/pass_through/%d/self", user_id));
+ result = PrepareDir(pass_through_linkpath, 0710, AID_ROOT, AID_MEDIA_RW);
+ if (result != android::OK) {
+ PLOG(ERROR) << "Failed to prepare directory " << pass_through_linkpath;
+ return -1;
+ }
+ pass_through_linkpath += "/primary";
+ Symlink("/storage/emulated/" + std::to_string(user_id), pass_through_linkpath);
+ }
+
+ // Open fuse fd.
+ fuse_fd->reset(open("/dev/fuse", O_RDWR | O_CLOEXEC));
+ if (fuse_fd->get() == -1) {
+ PLOG(ERROR) << "Failed to open /dev/fuse";
+ return -1;
+ }
+
+ // Note: leaving out default_permissions since we don't want kernel to do lower filesystem
+ // permission checks before routing to FUSE daemon.
+ const auto opts = StringPrintf(
+ "fd=%i,"
+ "rootmode=40000,"
+ "allow_other,"
+ "user_id=0,group_id=0,",
+ fuse_fd->get());
+
+ result = TEMP_FAILURE_RETRY(mount("/dev/fuse", fuse_path.c_str(), "fuse",
+ MS_NOSUID | MS_NODEV | MS_NOEXEC | MS_NOATIME | MS_LAZYTIME,
+ opts.c_str()));
+ if (result != 0) {
+ PLOG(ERROR) << "Failed to mount " << fuse_path;
+ return -errno;
+ }
+
+ if (IsFilesystemSupported("sdcardfs")) {
+ std::string sdcardfs_path(
+ StringPrintf("/mnt/runtime/full/%s", relative_upper_path.c_str()));
+
+ LOG(INFO) << "Bind mounting " << sdcardfs_path << " to " << pass_through_path;
+ return BindMount(sdcardfs_path, pass_through_path);
+ } else {
+ LOG(INFO) << "Bind mounting " << absolute_lower_path << " to " << pass_through_path;
+ return BindMount(absolute_lower_path, pass_through_path);
+ }
+}
+
+status_t UnmountUserFuse(userid_t user_id, const std::string& absolute_lower_path,
+ const std::string& relative_upper_path) {
+ std::string fuse_path(StringPrintf("/mnt/user/%d/%s", user_id, relative_upper_path.c_str()));
+ std::string pass_through_path(
+ StringPrintf("/mnt/pass_through/%d/%s", user_id, relative_upper_path.c_str()));
+
+ // Best effort unmount pass_through path
+ sSleepOnUnmount = false;
+ LOG(INFO) << "Unmounting pass_through_path " << pass_through_path;
+ auto status = ForceUnmount(pass_through_path);
+ if (status != android::OK) {
+ LOG(ERROR) << "Failed to unmount " << pass_through_path;
+ }
+ rmdir(pass_through_path.c_str());
+
+ LOG(INFO) << "Unmounting fuse path " << fuse_path;
+ android::status_t result = ForceUnmount(fuse_path);
+ sSleepOnUnmount = true;
+ if (result != android::OK) {
+ // TODO(b/135341433): MNT_DETACH is needed for fuse because umount2 can fail with EBUSY.
+ // Figure out why we get EBUSY and remove this special casing if possible.
+ PLOG(ERROR) << "Failed to unmount. Trying MNT_DETACH " << fuse_path << " ...";
+ if (umount2(fuse_path.c_str(), UMOUNT_NOFOLLOW | MNT_DETACH) && errno != EINVAL &&
+ errno != ENOENT) {
+ PLOG(ERROR) << "Failed to unmount with MNT_DETACH " << fuse_path;
+ return -errno;
+ }
+ result = android::OK;
+ }
+ rmdir(fuse_path.c_str());
+
+ return result;
+}
+
+status_t PrepareAndroidDirs(const std::string& volumeRoot) {
+ std::string androidDir = volumeRoot + kAndroidDir;
+ std::string androidDataDir = volumeRoot + kAppDataDir;
+ std::string androidObbDir = volumeRoot + kAppObbDir;
+ std::string androidMediaDir = volumeRoot + kAppMediaDir;
+
+ bool useSdcardFs = IsFilesystemSupported("sdcardfs");
+
+ if (fs_prepare_dir(androidDir.c_str(), 0771, AID_MEDIA_RW, AID_MEDIA_RW) != 0) {
+ PLOG(ERROR) << "Failed to create " << androidDir;
+ return -errno;
+ }
+
+ gid_t dataGid = useSdcardFs ? AID_MEDIA_RW : AID_EXT_DATA_RW;
+ if (fs_prepare_dir(androidDataDir.c_str(), 0771, AID_MEDIA_RW, dataGid) != 0) {
+ PLOG(ERROR) << "Failed to create " << androidDataDir;
+ return -errno;
+ }
+
+ gid_t obbGid = useSdcardFs ? AID_MEDIA_RW : AID_EXT_OBB_RW;
+ if (fs_prepare_dir(androidObbDir.c_str(), 0771, AID_MEDIA_RW, obbGid) != 0) {
+ PLOG(ERROR) << "Failed to create " << androidObbDir;
+ return -errno;
+ }
+
+ if (fs_prepare_dir(androidMediaDir.c_str(), 0771, AID_MEDIA_RW, AID_MEDIA_RW) != 0) {
+ PLOG(ERROR) << "Failed to create " << androidMediaDir;
+ return -errno;
+ }
+
+ return OK;
+}
} // namespace vold
} // namespace android
diff --git a/Utils.h b/Utils.h
index af4e401..54b8dd8 100644
--- a/Utils.h
+++ b/Utils.h
@@ -20,6 +20,7 @@
#include "KeyBuffer.h"
#include <android-base/macros.h>
+#include <android-base/unique_fd.h>
#include <cutils/multiuser.h>
#include <selinux/selinux.h>
#include <utils/Errors.h>
@@ -33,6 +34,8 @@
namespace android {
namespace vold {
+static const char* kPropFuse = "persist.sys.fuse";
+
/* SELinux contexts used depending on the block device type */
extern security_context_t sBlkidContext;
extern security_context_t sBlkidUntrustedContext;
@@ -45,6 +48,17 @@
status_t CreateDeviceNode(const std::string& path, dev_t dev);
status_t DestroyDeviceNode(const std::string& path);
+int SetQuotaInherit(const std::string& path);
+int SetQuotaProjectId(const std::string& path, long projectId);
+/*
+ * Creates and sets up an application-specific path on external
+ * storage with the correct ACL and project ID (if needed).
+ *
+ * ONLY for use with app-specific data directories on external storage!
+ * (eg, /Android/data/com.foo, /Android/obb/com.foo, etc.)
+ */
+int PrepareAppDirFromRoot(const std::string& path, const std::string& root, int appUid);
+
/* fs_prepare_dir wrapper that creates with SELinux context */
status_t PrepareDir(const std::string& path, mode_t mode, uid_t uid, gid_t gid);
@@ -147,6 +161,14 @@
bool FsyncDirectory(const std::string& dirname);
bool writeStringToFile(const std::string& payload, const std::string& filename);
+
+status_t MountUserFuse(userid_t user_id, const std::string& absolute_lower_path,
+ const std::string& relative_upper_path, android::base::unique_fd* fuse_fd);
+
+status_t UnmountUserFuse(userid_t userId, const std::string& absolute_lower_path,
+ const std::string& relative_upper_path);
+
+status_t PrepareAndroidDirs(const std::string& volumeRoot);
} // namespace vold
} // namespace android
diff --git a/VoldNativeService.cpp b/VoldNativeService.cpp
index 905407b..6aa9670 100644
--- a/VoldNativeService.cpp
+++ b/VoldNativeService.cpp
@@ -110,7 +110,7 @@
return exception(binder::Status::EX_ILLEGAL_ARGUMENT, "Missing ID");
}
for (const char& c : id) {
- if (!std::isalnum(c) && c != ':' && c != ',') {
+ if (!std::isalnum(c) && c != ':' && c != ',' && c != ';') {
return exception(binder::Status::EX_ILLEGAL_ARGUMENT,
StringPrintf("ID %s is malformed", id.c_str()));
}
@@ -328,8 +328,9 @@
return translate(VolumeManager::Instance()->forgetPartition(partGuid, fsUuid));
}
-binder::Status VoldNativeService::mount(const std::string& volId, int32_t mountFlags,
- int32_t mountUserId) {
+binder::Status VoldNativeService::mount(
+ const std::string& volId, int32_t mountFlags, int32_t mountUserId,
+ const android::sp<android::os::IVoldMountCallback>& callback) {
ENFORCE_SYSTEM_OR_ROOT;
CHECK_ARGUMENT_ID(volId);
ACQUIRE_LOCK;
@@ -342,10 +343,14 @@
vol->setMountFlags(mountFlags);
vol->setMountUserId(mountUserId);
+ vol->setMountCallback(callback);
int res = vol->mount();
+ vol->setMountCallback(nullptr);
+
if (res != OK) {
return translate(res);
}
+
if ((mountFlags & MOUNT_FLAG_PRIMARY) != 0) {
res = VolumeManager::Instance()->setPrimary(vol);
if (res != OK) {
@@ -453,12 +458,12 @@
return translate(VolumeManager::Instance()->remountUid(uid, remountMode));
}
-binder::Status VoldNativeService::mkdirs(const std::string& path) {
+binder::Status VoldNativeService::setupAppDir(const std::string& path, int32_t appUid) {
ENFORCE_SYSTEM_OR_ROOT;
CHECK_ARGUMENT_PATH(path);
ACQUIRE_LOCK;
- return translate(VolumeManager::Instance()->mkdirs(path));
+ return translate(VolumeManager::Instance()->setupAppDir(path, appUid));
}
binder::Status VoldNativeService::createObb(const std::string& sourcePath,
@@ -481,9 +486,12 @@
return translate(VolumeManager::Instance()->destroyObb(volId));
}
-binder::Status VoldNativeService::createStubVolume(
- const std::string& sourcePath, const std::string& mountPath, const std::string& fsType,
- const std::string& fsUuid, const std::string& fsLabel, std::string* _aidl_return) {
+binder::Status VoldNativeService::createStubVolume(const std::string& sourcePath,
+ const std::string& mountPath,
+ const std::string& fsType,
+ const std::string& fsUuid,
+ const std::string& fsLabel, int32_t flags,
+ std::string* _aidl_return) {
ENFORCE_SYSTEM_OR_ROOT;
CHECK_ARGUMENT_PATH(sourcePath);
CHECK_ARGUMENT_PATH(mountPath);
@@ -492,8 +500,8 @@
// is quite meaningless.
ACQUIRE_LOCK;
- return translate(VolumeManager::Instance()->createStubVolume(sourcePath, mountPath, fsType,
- fsUuid, fsLabel, _aidl_return));
+ return translate(VolumeManager::Instance()->createStubVolume(
+ sourcePath, mountPath, fsType, fsUuid, fsLabel, flags, _aidl_return));
}
binder::Status VoldNativeService::destroyStubVolume(const std::string& volId) {
@@ -927,26 +935,26 @@
return ok();
}
-binder::Status VoldNativeService::incFsVersion(int32_t* _aidl_return) {
- *_aidl_return = IncFs_Version();
+binder::Status VoldNativeService::incFsEnabled(bool* _aidl_return) {
+ *_aidl_return = IncFs_IsEnabled();
return ok();
}
binder::Status VoldNativeService::mountIncFs(
- const std::string& imagePath, const std::string& targetDir, int32_t flags,
+ const std::string& backingPath, const std::string& targetDir, int32_t flags,
::android::os::incremental::IncrementalFileSystemControlParcel* _aidl_return) {
- auto result = IncFs_Mount(imagePath.c_str(), targetDir.c_str(), flags,
- INCFS_DEFAULT_READ_TIMEOUT_MS, 0777);
- if (result.cmdFd < 0) {
- return translate(result.cmdFd);
+ auto result = IncFs_Mount(backingPath.c_str(), targetDir.c_str(),
+ {.flags = IncFsMountFlags(flags),
+ .defaultReadTimeoutMs = INCFS_DEFAULT_READ_TIMEOUT_MS,
+ .readLogBufferPages = 4});
+ if (result.cmd < 0) {
+ return translate(result.cmd);
}
- LOG(INFO) << "VoldNativeService::mountIncFs: everything is fine! " << result.cmdFd << "/"
- << result.logFd;
- using ParcelFileDescriptor = ::android::os::ParcelFileDescriptor;
using unique_fd = ::android::base::unique_fd;
- _aidl_return->cmd = std::make_unique<ParcelFileDescriptor>(unique_fd(result.cmdFd));
- if (result.logFd >= 0) {
- _aidl_return->log = std::make_unique<ParcelFileDescriptor>(unique_fd(result.logFd));
+ _aidl_return->cmd.reset(unique_fd(result.cmd));
+ _aidl_return->pendingReads.reset(unique_fd(result.pendingReads));
+ if (result.logs >= 0) {
+ _aidl_return->log.reset(unique_fd(result.logs));
}
return ok();
}
diff --git a/VoldNativeService.h b/VoldNativeService.h
index 18551f2..6d00d2d 100644
--- a/VoldNativeService.h
+++ b/VoldNativeService.h
@@ -52,7 +52,8 @@
binder::Status partition(const std::string& diskId, int32_t partitionType, int32_t ratio);
binder::Status forgetPartition(const std::string& partGuid, const std::string& fsUuid);
- binder::Status mount(const std::string& volId, int32_t mountFlags, int32_t mountUserId);
+ binder::Status mount(const std::string& volId, int32_t mountFlags, int32_t mountUserId,
+ const android::sp<android::os::IVoldMountCallback>& callback);
binder::Status unmount(const std::string& volId);
binder::Status format(const std::string& volId, const std::string& fsType);
binder::Status benchmark(const std::string& volId,
@@ -64,7 +65,7 @@
binder::Status remountUid(int32_t uid, int32_t remountMode);
- binder::Status mkdirs(const std::string& path);
+ binder::Status setupAppDir(const std::string& path, int32_t appUid);
binder::Status createObb(const std::string& sourcePath, const std::string& sourceKey,
int32_t ownerGid, std::string* _aidl_return);
@@ -72,7 +73,8 @@
binder::Status createStubVolume(const std::string& sourcePath, const std::string& mountPath,
const std::string& fsType, const std::string& fsUuid,
- const std::string& fsLabel, std::string* _aidl_return);
+ const std::string& fsLabel, int32_t flags,
+ std::string* _aidl_return);
binder::Status destroyStubVolume(const std::string& volId);
binder::Status fstrim(int32_t fstrimFlags,
@@ -144,9 +146,9 @@
binder::Status supportsFileCheckpoint(bool* _aidl_return);
binder::Status resetCheckpoint();
- binder::Status incFsVersion(int32_t* _aidl_return) override;
+ binder::Status incFsEnabled(bool* _aidl_return) override;
binder::Status mountIncFs(
- const std::string& imagePath, const std::string& targetDir, int32_t flags,
+ const std::string& backingPath, const std::string& targetDir, int32_t flags,
::android::os::incremental::IncrementalFileSystemControlParcel* _aidl_return) override;
binder::Status unmountIncFs(const std::string& dir) override;
binder::Status bindMount(const std::string& sourceDir, const std::string& targetDir) override;
diff --git a/VolumeManager.cpp b/VolumeManager.cpp
index f860eef..6f15846 100644
--- a/VolumeManager.cpp
+++ b/VolumeManager.cpp
@@ -40,6 +40,7 @@
#include <android-base/properties.h>
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
+#include <async_safe/log.h>
#include <cutils/fs.h>
#include <utils/Trace.h>
@@ -66,6 +67,7 @@
#include "fs/Vfat.h"
#include "model/EmulatedVolume.h"
#include "model/ObbVolume.h"
+#include "model/PrivateVolume.h"
#include "model/StubVolume.h"
using android::OK;
@@ -78,10 +80,15 @@
using android::vold::CreateDir;
using android::vold::DeleteDirContents;
using android::vold::DeleteDirContentsAndDir;
+using android::vold::IsFilesystemSupported;
+using android::vold::PrepareAndroidDirs;
+using android::vold::PrepareAppDirFromRoot;
+using android::vold::PrivateVolume;
using android::vold::Symlink;
using android::vold::Unlink;
using android::vold::UnmountTree;
using android::vold::VoldNativeService;
+using android::vold::VolumeBase;
static const char* kPathUserMount = "/mnt/user";
static const char* kPathVirtualDisk = "/data/misc/vold/virtual_disk";
@@ -107,7 +114,7 @@
VolumeManager::VolumeManager() {
mDebug = false;
mNextObbId = 0;
- mNextStubVolumeId = 0;
+ mNextStubId = 0;
// For security reasons, assume that a secure keyguard is
// showing until we hear otherwise
mSecureKeyguardShowing = true;
@@ -173,10 +180,13 @@
// Assume that we always have an emulated volume on internal
// storage; the framework will decide if it should be mounted.
- CHECK(mInternalEmulated == nullptr);
- mInternalEmulated = std::shared_ptr<android::vold::VolumeBase>(
- new android::vold::EmulatedVolume("/data/media"));
- mInternalEmulated->create();
+ CHECK(mInternalEmulatedVolumes.empty());
+
+ auto vol = std::shared_ptr<android::vold::VolumeBase>(
+ new android::vold::EmulatedVolume("/data/media", 0));
+ vol->setMountUserId(0);
+ vol->create();
+ mInternalEmulatedVolumes.push_back(vol);
// Consider creating a virtual disk
updateVirtualDisk();
@@ -185,9 +195,12 @@
}
int VolumeManager::stop() {
- CHECK(mInternalEmulated != nullptr);
- mInternalEmulated->destroy();
- mInternalEmulated = nullptr;
+ CHECK(!mInternalEmulatedVolumes.empty());
+ for (const auto& vol : mInternalEmulatedVolumes) {
+ vol->destroy();
+ }
+ mInternalEmulatedVolumes.clear();
+
return 0;
}
@@ -252,10 +265,17 @@
void VolumeManager::handleDiskAdded(const std::shared_ptr<android::vold::Disk>& disk) {
// For security reasons, if secure keyguard is showing, wait
// until the user unlocks the device to actually touch it
+ // Additionally, wait until user 0 is actually started, since we need
+ // the user to be up before we can mount a FUSE daemon to handle the disk.
+ bool userZeroStarted = mStartedUsers.find(0) != mStartedUsers.end();
if (mSecureKeyguardShowing) {
LOG(INFO) << "Found disk at " << disk->getEventPath()
<< " but delaying scan due to secure keyguard";
mPendingDisks.push_back(disk);
+ } else if (!userZeroStarted) {
+ LOG(INFO) << "Found disk at " << disk->getEventPath()
+ << " but delaying scan due to user zero not having started";
+ mPendingDisks.push_back(disk);
} else {
disk->create();
mDisks.push_back(disk);
@@ -309,11 +329,10 @@
}
std::shared_ptr<android::vold::VolumeBase> VolumeManager::findVolume(const std::string& id) {
- // Vold could receive "mount" after "shutdown" command in the extreme case.
- // If this happens, mInternalEmulated will equal nullptr and
- // we need to deal with it in order to avoid null pointer crash.
- if (mInternalEmulated != nullptr && mInternalEmulated->getId() == id) {
- return mInternalEmulated;
+ for (const auto& vol : mInternalEmulatedVolumes) {
+ if (vol->getId() == id) {
+ return vol;
+ }
}
for (const auto& disk : mDisks) {
auto vol = disk->findVolume(id);
@@ -321,11 +340,6 @@
return vol;
}
}
- for (const auto& vol : mStubVolumes) {
- if (vol->getId() == id) {
- return vol;
- }
- }
for (const auto& vol : mObbVolumes) {
if (vol->getId() == id) {
return vol;
@@ -364,60 +378,145 @@
}
int VolumeManager::linkPrimary(userid_t userId) {
- std::string source(mPrimary->getPath());
- if (mPrimary->isEmulated()) {
- source = StringPrintf("%s/%d", source.c_str(), userId);
- fs_prepare_dir(source.c_str(), 0755, AID_ROOT, AID_ROOT);
- }
+ if (!GetBoolProperty(android::vold::kPropFuse, false)) {
+ std::string source(mPrimary->getPath());
+ if (mPrimary->isEmulated()) {
+ source = StringPrintf("%s/%d", source.c_str(), userId);
+ fs_prepare_dir(source.c_str(), 0755, AID_ROOT, AID_ROOT);
+ }
- std::string target(StringPrintf("/mnt/user/%d/primary", userId));
- LOG(DEBUG) << "Linking " << source << " to " << target;
- Symlink(source, target);
+ std::string target(StringPrintf("/mnt/user/%d/primary", userId));
+ LOG(DEBUG) << "Linking " << source << " to " << target;
+ Symlink(source, target);
+ }
return 0;
}
+void VolumeManager::destroyEmulatedVolumesForUser(userid_t userId) {
+ // Destroy and remove all unstacked EmulatedVolumes for the user
+ auto i = mInternalEmulatedVolumes.begin();
+ while (i != mInternalEmulatedVolumes.end()) {
+ auto vol = *i;
+ if (vol->getMountUserId() == userId) {
+ vol->destroy();
+ i = mInternalEmulatedVolumes.erase(i);
+ } else {
+ i++;
+ }
+ }
+
+ // Destroy and remove all stacked EmulatedVolumes for the user on each mounted private volume
+ std::list<std::string> private_vols;
+ listVolumes(VolumeBase::Type::kPrivate, private_vols);
+ for (const std::string& id : private_vols) {
+ PrivateVolume* pvol = static_cast<PrivateVolume*>(findVolume(id).get());
+ std::list<std::shared_ptr<VolumeBase>> vols_to_remove;
+ if (pvol->getState() == VolumeBase::State::kMounted) {
+ for (const auto& vol : pvol->getVolumes()) {
+ if (vol->getMountUserId() == userId) {
+ vols_to_remove.push_back(vol);
+ }
+ }
+ for (const auto& vol : vols_to_remove) {
+ vol->destroy();
+ pvol->removeVolume(vol);
+ }
+ } // else EmulatedVolumes will be destroyed on VolumeBase#unmount
+ }
+}
+
+void VolumeManager::createEmulatedVolumesForUser(userid_t userId) {
+ // Create unstacked EmulatedVolumes for the user
+ auto vol = std::shared_ptr<android::vold::VolumeBase>(
+ new android::vold::EmulatedVolume("/data/media", userId));
+ vol->setMountUserId(userId);
+ mInternalEmulatedVolumes.push_back(vol);
+ vol->create();
+
+ // Create stacked EmulatedVolumes for the user on each PrivateVolume
+ std::list<std::string> private_vols;
+ listVolumes(VolumeBase::Type::kPrivate, private_vols);
+ for (const std::string& id : private_vols) {
+ PrivateVolume* pvol = static_cast<PrivateVolume*>(findVolume(id).get());
+ if (pvol->getState() == VolumeBase::State::kMounted) {
+ auto evol =
+ std::shared_ptr<android::vold::VolumeBase>(new android::vold::EmulatedVolume(
+ pvol->getPath() + "/media", pvol->getRawDevice(), pvol->getFsUuid(),
+ userId));
+ evol->setMountUserId(userId);
+ pvol->addVolume(evol);
+ evol->create();
+ } // else EmulatedVolumes will be created per user when on PrivateVolume#doMount
+ }
+}
+
int VolumeManager::onUserAdded(userid_t userId, int userSerialNumber) {
+ LOG(INFO) << "onUserAdded: " << userId;
+
mAddedUsers[userId] = userSerialNumber;
return 0;
}
int VolumeManager::onUserRemoved(userid_t userId) {
+ LOG(INFO) << "onUserRemoved: " << userId;
+
+ onUserStopped(userId);
mAddedUsers.erase(userId);
return 0;
}
int VolumeManager::onUserStarted(userid_t userId) {
- LOG(VERBOSE) << "onUserStarted: " << userId;
- // Note that sometimes the system will spin up processes from Zygote
- // before actually starting the user, so we're okay if Zygote
- // already created this directory.
- std::string path(StringPrintf("%s/%d", kPathUserMount, userId));
- fs_prepare_dir(path.c_str(), 0755, AID_ROOT, AID_ROOT);
+ LOG(INFO) << "onUserStarted: " << userId;
+
+ if (mStartedUsers.find(userId) == mStartedUsers.end()) {
+ createEmulatedVolumesForUser(userId);
+ }
+
+ if (!GetBoolProperty(android::vold::kPropFuse, false)) {
+ // Note that sometimes the system will spin up processes from Zygote
+ // before actually starting the user, so we're okay if Zygote
+ // already created this directory.
+ std::string path(StringPrintf("%s/%d", kPathUserMount, userId));
+ fs_prepare_dir(path.c_str(), 0755, AID_ROOT, AID_ROOT);
+
+ if (mPrimary) {
+ linkPrimary(userId);
+ }
+ }
mStartedUsers.insert(userId);
- if (mPrimary) {
- linkPrimary(userId);
- }
+
+ createPendingDisksIfNeeded();
return 0;
}
int VolumeManager::onUserStopped(userid_t userId) {
LOG(VERBOSE) << "onUserStopped: " << userId;
+
+ if (mStartedUsers.find(userId) != mStartedUsers.end()) {
+ destroyEmulatedVolumesForUser(userId);
+ }
+
mStartedUsers.erase(userId);
return 0;
}
-int VolumeManager::onSecureKeyguardStateChanged(bool isShowing) {
- mSecureKeyguardShowing = isShowing;
- if (!mSecureKeyguardShowing) {
- // Now that secure keyguard has been dismissed, process
- // any pending disks
+void VolumeManager::createPendingDisksIfNeeded() {
+ bool userZeroStarted = mStartedUsers.find(0) != mStartedUsers.end();
+ if (!mSecureKeyguardShowing && userZeroStarted) {
+ // Now that secure keyguard has been dismissed and user 0 has
+ // started, process any pending disks
for (const auto& disk : mPendingDisks) {
disk->create();
mDisks.push_back(disk);
}
mPendingDisks.clear();
}
+}
+
+int VolumeManager::onSecureKeyguardStateChanged(bool isShowing) {
+ mSecureKeyguardShowing = isShowing;
+ createPendingDisksIfNeeded();
return 0;
}
@@ -429,7 +528,56 @@
return 0;
}
+// This code is executed after a fork so it's very important that the set of
+// methods we call here is strictly limited.
+//
+// TODO: Get rid of this guesswork altogether and instead exec a process
+// immediately after fork to do our bindding for us.
+static bool childProcess(const char* storageSource, const char* userSource, int nsFd,
+ struct dirent* de) {
+ if (setns(nsFd, CLONE_NEWNS) != 0) {
+ async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to setns for %s :%s", de->d_name,
+ strerror(errno));
+ return false;
+ }
+
+ // NOTE: Inlined from vold::UnmountTree here to avoid using PLOG methods and
+ // to also protect against future changes that may cause issues across a
+ // fork.
+ if (TEMP_FAILURE_RETRY(umount2("/storage/", MNT_DETACH)) < 0 && errno != EINVAL &&
+ errno != ENOENT) {
+ async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to unmount /storage/ :%s",
+ strerror(errno));
+ return false;
+ }
+
+ if (TEMP_FAILURE_RETRY(mount(storageSource, "/storage", NULL, MS_BIND | MS_REC, NULL)) == -1) {
+ async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to mount %s for %s :%s",
+ storageSource, de->d_name, strerror(errno));
+ return false;
+ }
+
+ if (TEMP_FAILURE_RETRY(mount(NULL, "/storage", NULL, MS_REC | MS_SLAVE, NULL)) == -1) {
+ async_safe_format_log(ANDROID_LOG_ERROR, "vold",
+ "Failed to set MS_SLAVE to /storage for %s :%s", de->d_name,
+ strerror(errno));
+ return false;
+ }
+
+ if (TEMP_FAILURE_RETRY(mount(userSource, "/storage/self", NULL, MS_BIND, NULL)) == -1) {
+ async_safe_format_log(ANDROID_LOG_ERROR, "vold", "Failed to mount %s for %s :%s",
+ userSource, de->d_name, strerror(errno));
+ return false;
+ }
+
+ return true;
+}
+
int VolumeManager::remountUid(uid_t uid, int32_t mountMode) {
+ if (GetBoolProperty(android::vold::kPropFuse, false)) {
+ // TODO(135341433): Implement fuse specific logic.
+ return 0;
+ }
std::string mode;
switch (mountMode) {
case VoldNativeService::REMOUNT_MODE_NONE:
@@ -449,6 +597,9 @@
case VoldNativeService::REMOUNT_MODE_FULL:
mode = "full";
break;
+ case VoldNativeService::REMOUNT_MODE_PASS_THROUGH:
+ mode = "pass_through";
+ break;
default:
PLOG(ERROR) << "Unknown mode " << std::to_string(mountMode);
return -1;
@@ -463,6 +614,8 @@
int nsFd;
struct stat sb;
pid_t child;
+ std::string userSource;
+ std::string storageSource;
static bool apexUpdatable = android::sysprop::ApexProperties::updatable().value_or(false);
@@ -538,47 +691,28 @@
goto next;
}
+ if (mode == "default") {
+ storageSource = "/mnt/runtime/default";
+ } else if (mode == "read") {
+ storageSource = "/mnt/runtime/read";
+ } else if (mode == "write") {
+ storageSource = "/mnt/runtime/write";
+ } else if (mode == "full") {
+ storageSource = "/mnt/runtime/full";
+ } else {
+ // Sane default of no storage visible. No need to fork a child
+ // to remount uid.
+ goto next;
+ }
+
+ // Mount user-specific symlink helper into place
+ userSource = StringPrintf("/mnt/user/%d", multiuser_get_user_id(uid));
if (!(child = fork())) {
- if (setns(nsFd, CLONE_NEWNS) != 0) {
- PLOG(ERROR) << "Failed to setns for " << de->d_name;
- _exit(1);
- }
-
- android::vold::UnmountTree("/storage/");
-
- std::string storageSource;
- if (mode == "default") {
- storageSource = "/mnt/runtime/default";
- } else if (mode == "read") {
- storageSource = "/mnt/runtime/read";
- } else if (mode == "write") {
- storageSource = "/mnt/runtime/write";
- } else if (mode == "full") {
- storageSource = "/mnt/runtime/full";
- } else {
- // Sane default of no storage visible
+ if (childProcess(storageSource.c_str(), userSource.c_str(), nsFd, de)) {
_exit(0);
- }
- if (TEMP_FAILURE_RETRY(
- mount(storageSource.c_str(), "/storage", NULL, MS_BIND | MS_REC, NULL)) == -1) {
- PLOG(ERROR) << "Failed to mount " << storageSource << " for " << de->d_name;
+ } else {
_exit(1);
}
- if (TEMP_FAILURE_RETRY(mount(NULL, "/storage", NULL, MS_REC | MS_SLAVE, NULL)) == -1) {
- PLOG(ERROR) << "Failed to set MS_SLAVE to /storage for " << de->d_name;
- _exit(1);
- }
-
- // Mount user-specific symlink helper into place
- userid_t user_id = multiuser_get_user_id(uid);
- std::string userSource(StringPrintf("/mnt/user/%d", user_id));
- if (TEMP_FAILURE_RETRY(
- mount(userSource.c_str(), "/storage/self", NULL, MS_BIND, NULL)) == -1) {
- PLOG(ERROR) << "Failed to mount " << userSource << " for " << de->d_name;
- _exit(1);
- }
-
- _exit(0);
}
if (child == -1) {
@@ -599,10 +733,11 @@
int VolumeManager::reset() {
// Tear down all existing disks/volumes and start from a blank slate so
// newly connected framework hears all events.
- if (mInternalEmulated != nullptr) {
- mInternalEmulated->destroy();
- mInternalEmulated->create();
+ for (const auto& vol : mInternalEmulatedVolumes) {
+ vol->destroy();
}
+ mInternalEmulatedVolumes.clear();
+
for (const auto& disk : mDisks) {
disk->destroy();
disk->create();
@@ -615,16 +750,18 @@
// Can be called twice (sequentially) during shutdown. should be safe for that.
int VolumeManager::shutdown() {
- if (mInternalEmulated == nullptr) {
+ if (mInternalEmulatedVolumes.empty()) {
return 0; // already shutdown
}
android::vold::sSleepOnUnmount = false;
- mInternalEmulated->destroy();
- mInternalEmulated = nullptr;
+ for (const auto& vol : mInternalEmulatedVolumes) {
+ vol->destroy();
+ }
for (const auto& disk : mDisks) {
disk->destroy();
}
- mStubVolumes.clear();
+
+ mInternalEmulatedVolumes.clear();
mDisks.clear();
mPendingDisks.clear();
android::vold::sSleepOnUnmount = true;
@@ -636,11 +773,8 @@
ATRACE_NAME("VolumeManager::unmountAll()");
// First, try gracefully unmounting all known devices
- if (mInternalEmulated != nullptr) {
- mInternalEmulated->unmount();
- }
- for (const auto& stub : mStubVolumes) {
- stub->unmount();
+ for (const auto& vol : mInternalEmulatedVolumes) {
+ vol->unmount();
}
for (const auto& disk : mDisks) {
disk->unmountAll();
@@ -664,7 +798,8 @@
#ifdef __ANDROID_DEBUGGABLE__
!StartsWith(test, "/mnt/scratch") &&
#endif
- !StartsWith(test, "/mnt/vendor") && !StartsWith(test, "/mnt/product")) ||
+ !StartsWith(test, "/mnt/vendor") && !StartsWith(test, "/mnt/product") &&
+ !StartsWith(test, "/mnt/installer")) ||
StartsWith(test, "/storage/")) {
toUnmount.push_front(test);
}
@@ -679,15 +814,53 @@
return 0;
}
-int VolumeManager::mkdirs(const std::string& path) {
+int VolumeManager::setupAppDir(const std::string& path, int32_t appUid) {
// Only offer to create directories for paths managed by vold
- if (StartsWith(path, "/storage/")) {
- // fs_mkdirs() does symlink checking and relative path enforcement
- return fs_mkdirs(path.c_str(), 0700);
- } else {
+ if (!StartsWith(path, "/storage/")) {
LOG(ERROR) << "Failed to find mounted volume for " << path;
return -EINVAL;
}
+
+ // Find the volume it belongs to
+ auto filter_fn = [&](const VolumeBase& vol) {
+ if (vol.getState() != VolumeBase::State::kMounted) {
+ // The volume must be mounted
+ return false;
+ }
+ if ((vol.getMountFlags() & VolumeBase::MountFlags::kVisible) == 0) {
+ // and visible
+ return false;
+ }
+ if (vol.getInternalPath().empty()) {
+ return false;
+ }
+ if (vol.getMountUserId() != USER_UNKNOWN &&
+ vol.getMountUserId() != multiuser_get_user_id(appUid)) {
+ // The app dir must be created on a volume with the same user-id
+ return false;
+ }
+ if (!path.empty() && StartsWith(path, vol.getPath())) {
+ return true;
+ }
+
+ return false;
+ };
+ auto volume = findVolumeWithFilter(filter_fn);
+ if (volume == nullptr) {
+ LOG(ERROR) << "Failed to find mounted volume for " << path;
+ return -EINVAL;
+ }
+ // Convert paths to lower filesystem paths to avoid making FUSE requests for these reasons:
+ // 1. A FUSE request from vold puts vold at risk of hanging if the FUSE daemon is down
+ // 2. The FUSE daemon prevents requests on /mnt/user/0/emulated/<userid != 0> and a request
+ // on /storage/emulated/10 means /mnt/user/0/emulated/10
+ const std::string lowerPath =
+ volume->getInternalPath() + path.substr(volume->getPath().length());
+
+ const std::string volumeRoot = volume->getRootPath(); // eg /data/media/0
+
+ // Create the app paths we need from the root
+ return PrepareAppDirFromRoot(lowerPath, volumeRoot, appUid);
}
int VolumeManager::createObb(const std::string& sourcePath, const std::string& sourceKey,
@@ -718,27 +891,31 @@
int VolumeManager::createStubVolume(const std::string& sourcePath, const std::string& mountPath,
const std::string& fsType, const std::string& fsUuid,
- const std::string& fsLabel, std::string* outVolId) {
- int id = mNextStubVolumeId++;
- auto vol = std::shared_ptr<android::vold::VolumeBase>(
- new android::vold::StubVolume(id, sourcePath, mountPath, fsType, fsUuid, fsLabel));
- vol->create();
+ const std::string& fsLabel, int32_t flags,
+ std::string* outVolId) {
+ dev_t stubId = --mNextStubId;
+ auto vol = std::shared_ptr<android::vold::StubVolume>(
+ new android::vold::StubVolume(stubId, sourcePath, mountPath, fsType, fsUuid, fsLabel));
- mStubVolumes.push_back(vol);
+ int32_t passedFlags = android::vold::Disk::Flags::kStub;
+ passedFlags |= (flags & android::vold::Disk::Flags::kUsb);
+ passedFlags |= (flags & android::vold::Disk::Flags::kSd);
+ // StubDisk doesn't have device node corresponds to it. So, a fake device
+ // number is used.
+ auto disk = std::shared_ptr<android::vold::Disk>(
+ new android::vold::Disk("stub", stubId, "stub", passedFlags));
+ disk->initializePartition(vol);
+ handleDiskAdded(disk);
*outVolId = vol->getId();
return android::OK;
}
int VolumeManager::destroyStubVolume(const std::string& volId) {
- auto i = mStubVolumes.begin();
- while (i != mStubVolumes.end()) {
- if ((*i)->getId() == volId) {
- (*i)->destroy();
- i = mStubVolumes.erase(i);
- } else {
- ++i;
- }
- }
+ auto tokens = android::base::Split(volId, ":");
+ CHECK(tokens.size() == 2);
+ dev_t stubId;
+ CHECK(android::base::ParseUint(tokens[1], &stubId));
+ handleDiskRemoved(stubId);
return android::OK;
}
diff --git a/VolumeManager.h b/VolumeManager.h
index 9bf7599..765349d 100644
--- a/VolumeManager.h
+++ b/VolumeManager.h
@@ -23,6 +23,7 @@
#include <list>
#include <mutex>
+#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
@@ -82,8 +83,28 @@
std::shared_ptr<android::vold::Disk> findDisk(const std::string& id);
std::shared_ptr<android::vold::VolumeBase> findVolume(const std::string& id);
+ template <typename Fn>
+ std::shared_ptr<android::vold::VolumeBase> findVolumeWithFilter(Fn fn) {
+ for (const auto& vol : mInternalEmulatedVolumes) {
+ if (fn(*vol)) {
+ return vol;
+ }
+ }
+ for (const auto& disk : mDisks) {
+ for (const auto& vol : disk->getVolumes()) {
+ if (fn(*vol)) {
+ return vol;
+ }
+ }
+ }
+
+ return nullptr;
+ }
+
void listVolumes(android::vold::VolumeBase::Type type, std::list<std::string>& list) const;
+ const std::set<userid_t>& getStartedUsers() const { return mStartedUsers; }
+
int forgetPartition(const std::string& partGuid, const std::string& fsUuid);
int onUserAdded(userid_t userId, int userSerialNumber);
@@ -91,6 +112,7 @@
int onUserStarted(userid_t userId);
int onUserStopped(userid_t userId);
+ void createPendingDisksIfNeeded();
int onSecureKeyguardStateChanged(bool isShowing);
int setPrimary(const std::shared_ptr<android::vold::VolumeBase>& vol);
@@ -110,13 +132,37 @@
static VolumeManager* Instance();
/*
- * Ensure that all directories along given path exist, creating parent
- * directories as needed. Validates that given path is absolute and that
- * it contains no relative "." or ".." paths or symlinks. Last path segment
- * is treated as filename and ignored, unless the path ends with "/". Also
- * ensures that path belongs to a volume managed by vold.
+ * Creates a directory 'path' for an application, automatically creating
+ * directories along the given path if they don't exist yet.
+ *
+ * Example:
+ * path = /storage/emulated/0/Android/data/com.foo/files/
+ *
+ * This function will first match the first part of the path with the volume
+ * root of any known volumes; in this case, "/storage/emulated/0" matches
+ * with the volume root of the emulated volume for user 0.
+ *
+ * The subseqent part of the path must start with one of the well-known
+ * Android/ data directories, /Android/data, /Android/obb or
+ * /Android/media.
+ *
+ * The final part of the path is application specific. This function will
+ * create all directories, including the application-specific ones, and
+ * set the UID of all app-specific directories below the well-known data
+ * directories to the 'appUid' argument. In the given example, the UID
+ * of /storage/emulated/0/Android/data/com.foo and
+ * /storage/emulated/0/Android/data/com.foo/files would be set to 'appUid'.
+ *
+ * The UID/GID of the parent directories will be set according to the
+ * requirements of the underlying filesystem and are of no concern to the
+ * caller.
+ *
+ * Validates that given paths are absolute and that they contain no relative
+ * "." or ".." paths or symlinks. Last path segment is treated as filename
+ * and ignored, unless the path ends with "/". Also ensures that path
+ * belongs to a volume managed by vold.
*/
- int mkdirs(const std::string& path);
+ int setupAppDir(const std::string& path, int32_t appUid);
int createObb(const std::string& path, const std::string& key, int32_t ownerGid,
std::string* outVolId);
@@ -124,7 +170,7 @@
int createStubVolume(const std::string& sourcePath, const std::string& mountPath,
const std::string& fsType, const std::string& fsUuid,
- const std::string& fsLabel, std::string* outVolId);
+ const std::string& fsLabel, int32_t flags, std::string* outVolId);
int destroyStubVolume(const std::string& volId);
int mountAppFuse(uid_t uid, int mountId, android::base::unique_fd* device_fd);
@@ -137,6 +183,9 @@
int linkPrimary(userid_t userId);
+ void createEmulatedVolumesForUser(userid_t userId);
+ void destroyEmulatedVolumesForUser(userid_t userId);
+
void handleDiskAdded(const std::shared_ptr<android::vold::Disk>& disk);
void handleDiskChanged(dev_t device);
void handleDiskRemoved(dev_t device);
@@ -150,18 +199,19 @@
std::list<std::shared_ptr<android::vold::Disk>> mDisks;
std::list<std::shared_ptr<android::vold::Disk>> mPendingDisks;
std::list<std::shared_ptr<android::vold::VolumeBase>> mObbVolumes;
- std::list<std::shared_ptr<android::vold::VolumeBase>> mStubVolumes;
+ std::list<std::shared_ptr<android::vold::VolumeBase>> mInternalEmulatedVolumes;
std::unordered_map<userid_t, int> mAddedUsers;
- std::unordered_set<userid_t> mStartedUsers;
+ // This needs to be a regular set because we care about the ordering here;
+ // user 0 should always go first, because it is responsible for sdcardfs.
+ std::set<userid_t> mStartedUsers;
std::string mVirtualDiskPath;
std::shared_ptr<android::vold::Disk> mVirtualDisk;
- std::shared_ptr<android::vold::VolumeBase> mInternalEmulated;
std::shared_ptr<android::vold::VolumeBase> mPrimary;
int mNextObbId;
- int mNextStubVolumeId;
+ int mNextStubId;
bool mSecureKeyguardShowing;
};
diff --git a/binder/android/os/IVold.aidl b/binder/android/os/IVold.aidl
index a454bd1..78598b3 100644
--- a/binder/android/os/IVold.aidl
+++ b/binder/android/os/IVold.aidl
@@ -18,6 +18,7 @@
import android.os.incremental.IncrementalFileSystemControlParcel;
import android.os.IVoldListener;
+import android.os.IVoldMountCallback;
import android.os.IVoldTaskListener;
/** {@hide} */
@@ -41,7 +42,8 @@
void partition(@utf8InCpp String diskId, int partitionType, int ratio);
void forgetPartition(@utf8InCpp String partGuid, @utf8InCpp String fsUuid);
- void mount(@utf8InCpp String volId, int mountFlags, int mountUserId);
+ void mount(@utf8InCpp String volId, int mountFlags, int mountUserId,
+ @nullable IVoldMountCallback callback);
void unmount(@utf8InCpp String volId);
void format(@utf8InCpp String volId, @utf8InCpp String fsType);
void benchmark(@utf8InCpp String volId, IVoldTaskListener listener);
@@ -52,7 +54,7 @@
void remountUid(int uid, int remountMode);
- void mkdirs(@utf8InCpp String path);
+ void setupAppDir(@utf8InCpp String path, int appUid);
@utf8InCpp String createObb(@utf8InCpp String sourcePath, @utf8InCpp String sourceKey,
int ownerGid);
@@ -123,13 +125,13 @@
@utf8InCpp String createStubVolume(@utf8InCpp String sourcePath,
@utf8InCpp String mountPath, @utf8InCpp String fsType,
- @utf8InCpp String fsUuid, @utf8InCpp String fsLabel);
+ @utf8InCpp String fsUuid, @utf8InCpp String fsLabel, int flags);
void destroyStubVolume(@utf8InCpp String volId);
FileDescriptor openAppFuseFile(int uid, int mountId, int fileId, int flags);
- int incFsVersion();
- IncrementalFileSystemControlParcel mountIncFs(@utf8InCpp String imagePath, @utf8InCpp String targetDir, int flags);
+ boolean incFsEnabled();
+ IncrementalFileSystemControlParcel mountIncFs(@utf8InCpp String backingPath, @utf8InCpp String targetDir, int flags);
void unmountIncFs(@utf8InCpp String dir);
void bindMount(@utf8InCpp String sourceDir, @utf8InCpp String targetDir);
@@ -166,6 +168,8 @@
const int REMOUNT_MODE_LEGACY = 4;
const int REMOUNT_MODE_INSTALLER = 5;
const int REMOUNT_MODE_FULL = 6;
+ const int REMOUNT_MODE_PASS_THROUGH = 7;
+ const int REMOUNT_MODE_ANDROID_WRITABLE = 8;
const int VOLUME_STATE_UNMOUNTED = 0;
const int VOLUME_STATE_CHECKING = 1;
diff --git a/binder/android/os/IVoldListener.aidl b/binder/android/os/IVoldListener.aidl
index 0dcfc04..b3e4ba5 100644
--- a/binder/android/os/IVoldListener.aidl
+++ b/binder/android/os/IVoldListener.aidl
@@ -25,7 +25,7 @@
void onDiskDestroyed(@utf8InCpp String diskId);
void onVolumeCreated(@utf8InCpp String volId,
- int type, @utf8InCpp String diskId, @utf8InCpp String partGuid);
+ int type, @utf8InCpp String diskId, @utf8InCpp String partGuid, int userId);
void onVolumeStateChanged(@utf8InCpp String volId, int state);
void onVolumeMetadataChanged(@utf8InCpp String volId,
@utf8InCpp String fsType, @utf8InCpp String fsUuid, @utf8InCpp String fsLabel);
diff --git a/binder/android/os/IVoldMountCallback.aidl b/binder/android/os/IVoldMountCallback.aidl
new file mode 100644
index 0000000..6bf46d7
--- /dev/null
+++ b/binder/android/os/IVoldMountCallback.aidl
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2019 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.
+ */
+
+package android.os;
+
+/** {@hide} */
+interface IVoldMountCallback {
+ boolean onVolumeChecking(FileDescriptor fuseFd, @utf8InCpp String path,
+ @utf8InCpp String internalPath);
+}
diff --git a/cryptfs.cpp b/cryptfs.cpp
index 38661f3..530d78e 100644
--- a/cryptfs.cpp
+++ b/cryptfs.cpp
@@ -65,6 +65,9 @@
#include <time.h>
#include <unistd.h>
+#include <chrono>
+#include <thread>
+
extern "C" {
#include <crypto_scrypt.h>
}
@@ -1128,9 +1131,22 @@
}
static int delete_crypto_blk_dev(const std::string& name) {
+ bool ret;
auto& dm = DeviceMapper::Instance();
- if (!dm.DeleteDevice(name)) {
- SLOGE("Cannot remove dm-crypt device %s: %s\n", name.c_str(), strerror(errno));
+ // TODO(b/149396179) there appears to be a race somewhere in the system where trying
+ // to delete the device fails with EBUSY; for now, work around this by retrying.
+ int tries = 5;
+ while (tries-- > 0) {
+ ret = dm.DeleteDevice(name);
+ if (ret || errno != EBUSY) {
+ break;
+ }
+ SLOGW("DM_DEV Cannot remove dm-crypt device %s: %s, retrying...\n", name.c_str(),
+ strerror(errno));
+ std::this_thread::sleep_for(std::chrono::milliseconds(100));
+ }
+ if (!ret) {
+ SLOGE("DM_DEV Cannot remove dm-crypt device %s: %s\n", name.c_str(), strerror(errno));
return -1;
}
return 0;
diff --git a/model/Disk.cpp b/model/Disk.cpp
index bfaf2cd..7ecc89e 100644
--- a/model/Disk.cpp
+++ b/model/Disk.cpp
@@ -162,6 +162,17 @@
}
}
+std::vector<std::shared_ptr<VolumeBase>> Disk::getVolumes() const {
+ std::vector<std::shared_ptr<VolumeBase>> vols;
+ for (const auto& vol : mVolumes) {
+ vols.push_back(vol);
+ auto stackedVolumes = vol->getVolumes();
+ vols.insert(vols.end(), stackedVolumes.begin(), stackedVolumes.end());
+ }
+
+ return vols;
+}
+
status_t Disk::create() {
CHECK(!mCreated);
mCreated = true;
@@ -169,6 +180,10 @@
auto listener = VolumeManager::Instance()->getListener();
if (listener) listener->onDiskCreated(getId(), mFlags);
+ if (isStub()) {
+ createStubVolume();
+ return OK;
+ }
readMetadata();
readPartitions();
return OK;
@@ -233,6 +248,15 @@
vol->create();
}
+void Disk::createStubVolume() {
+ CHECK(mVolumes.size() == 1);
+ auto listener = VolumeManager::Instance()->getListener();
+ if (listener) listener->onDiskMetadataChanged(getId(), mSize, mLabel, mSysPath);
+ if (listener) listener->onDiskScanned(getId());
+ mVolumes[0]->setDiskId(getId());
+ mVolumes[0]->create();
+}
+
void Disk::destroyAllVolumes() {
for (const auto& vol : mVolumes) {
vol->destroy();
@@ -433,6 +457,12 @@
return OK;
}
+void Disk::initializePartition(std::shared_ptr<StubVolume> vol) {
+ CHECK(isStub());
+ CHECK(mVolumes.empty());
+ mVolumes.push_back(vol);
+}
+
status_t Disk::unmountAll() {
for (const auto& vol : mVolumes) {
vol->unmount();
diff --git a/model/Disk.h b/model/Disk.h
index 889e906..99c98fc 100644
--- a/model/Disk.h
+++ b/model/Disk.h
@@ -17,6 +17,7 @@
#ifndef ANDROID_VOLD_DISK_H
#define ANDROID_VOLD_DISK_H
+#include "StubVolume.h"
#include "Utils.h"
#include "VolumeBase.h"
@@ -52,6 +53,9 @@
kUsb = 1 << 3,
/* Flag that disk is EMMC internal */
kEmmc = 1 << 4,
+ /* Flag that disk is Stub disk, i.e., disk that is managed from outside
+ * Android (e.g., ARC++). */
+ kStub = 1 << 5,
};
const std::string& getId() const { return mId; }
@@ -67,11 +71,14 @@
void listVolumes(VolumeBase::Type type, std::list<std::string>& list) const;
+ std::vector<std::shared_ptr<VolumeBase>> getVolumes() const;
+
status_t create();
status_t destroy();
status_t readMetadata();
status_t readPartitions();
+ void initializePartition(std::shared_ptr<StubVolume> vol);
status_t unmountAll();
@@ -107,11 +114,14 @@
void createPublicVolume(dev_t device);
void createPrivateVolume(dev_t device, const std::string& partGuid);
+ void createStubVolume();
void destroyAllVolumes();
int getMaxMinors();
+ bool isStub() { return mFlags & kStub; }
+
DISALLOW_COPY_AND_ASSIGN(Disk);
};
diff --git a/model/EmulatedVolume.cpp b/model/EmulatedVolume.cpp
index 552fe2f..8f8c87a 100644
--- a/model/EmulatedVolume.cpp
+++ b/model/EmulatedVolume.cpp
@@ -15,10 +15,13 @@
*/
#include "EmulatedVolume.h"
+
+#include "AppFuseUtil.h"
#include "Utils.h"
#include "VolumeManager.h"
#include <android-base/logging.h>
+#include <android-base/properties.h>
#include <android-base/stringprintf.h>
#include <cutils/fs.h>
#include <private/android_filesystem_config.h>
@@ -37,117 +40,288 @@
namespace android {
namespace vold {
-static const char* kFusePath = "/system/bin/sdcard";
+static const char* kSdcardFsPath = "/system/bin/sdcard";
-EmulatedVolume::EmulatedVolume(const std::string& rawPath)
- : VolumeBase(Type::kEmulated), mFusePid(0) {
- setId("emulated");
+EmulatedVolume::EmulatedVolume(const std::string& rawPath, int userId)
+ : VolumeBase(Type::kEmulated) {
+ setId(StringPrintf("emulated;%u", userId));
mRawPath = rawPath;
mLabel = "emulated";
+ mFuseMounted = false;
+ mUseSdcardFs = IsFilesystemSupported("sdcardfs");
}
-EmulatedVolume::EmulatedVolume(const std::string& rawPath, dev_t device, const std::string& fsUuid)
- : VolumeBase(Type::kEmulated), mFusePid(0) {
- setId(StringPrintf("emulated:%u,%u", major(device), minor(device)));
+EmulatedVolume::EmulatedVolume(const std::string& rawPath, dev_t device, const std::string& fsUuid,
+ int userId)
+ : VolumeBase(Type::kEmulated) {
+ setId(StringPrintf("emulated:%u,%u;%u", major(device), minor(device), userId));
mRawPath = rawPath;
mLabel = fsUuid;
+ mFuseMounted = false;
+ mUseSdcardFs = IsFilesystemSupported("sdcardfs");
}
EmulatedVolume::~EmulatedVolume() {}
-status_t EmulatedVolume::doMount() {
+std::string EmulatedVolume::getLabel() {
// We could have migrated storage to an adopted private volume, so always
// call primary storage "emulated" to avoid media rescans.
- std::string label = mLabel;
if (getMountFlags() & MountFlags::kPrimary) {
- label = "emulated";
+ return "emulated";
+ } else {
+ return mLabel;
+ }
+}
+
+// Creates a bind mount from source to target
+static status_t doFuseBindMount(const std::string& source, const std::string& target) {
+ LOG(INFO) << "Bind mounting " << source << " on " << target;
+ auto status = BindMount(source, target);
+ if (status != OK) {
+ return status;
+ }
+ LOG(INFO) << "Bind mounted " << source << " on " << target;
+ return OK;
+}
+
+status_t EmulatedVolume::mountFuseBindMounts() {
+ std::string androidSource;
+ std::string label = getLabel();
+ int userId = getMountUserId();
+
+ if (mUseSdcardFs) {
+ androidSource = StringPrintf("/mnt/runtime/default/%s/%d/Android", label.c_str(), userId);
+ } else {
+ androidSource = StringPrintf("/%s/%d/Android", mRawPath.c_str(), userId);
+ }
+ std::string androidTarget(
+ StringPrintf("/mnt/user/%d/%s/%d/Android", userId, label.c_str(), userId));
+
+ auto status = doFuseBindMount(androidSource, androidTarget);
+ if (status != OK) {
+ return status;
}
- mFuseDefault = StringPrintf("/mnt/runtime/default/%s", label.c_str());
- mFuseRead = StringPrintf("/mnt/runtime/read/%s", label.c_str());
- mFuseWrite = StringPrintf("/mnt/runtime/write/%s", label.c_str());
- mFuseFull = StringPrintf("/mnt/runtime/full/%s", label.c_str());
+ // Installers get the same view as all other apps, with the sole exception that the
+ // OBB dirs (Android/obb) are writable to them. On sdcardfs devices, this requires
+ // a special bind mount, since app-private and OBB dirs share the same GID, but we
+ // only want to give access to the latter.
+ if (!mUseSdcardFs) {
+ return OK;
+ }
+ std::string installerSource(
+ StringPrintf("/mnt/runtime/write/%s/%d/Android/obb", label.c_str(), userId));
+ std::string installerTarget(
+ StringPrintf("/mnt/installer/%d/%s/%d/Android/obb", userId, label.c_str(), userId));
+
+ status = doFuseBindMount(installerSource, installerTarget);
+ if (status != OK) {
+ return status;
+ }
+ return OK;
+}
+
+status_t EmulatedVolume::unmountFuseBindMounts() {
+ std::string label = getLabel();
+ int userId = getMountUserId();
+
+ if (mUseSdcardFs) {
+ std::string installerTarget(
+ StringPrintf("/mnt/installer/%d/%s/%d/Android/obb", userId, label.c_str(), userId));
+ LOG(INFO) << "Unmounting " << installerTarget;
+ auto status = UnmountTree(installerTarget);
+ if (status != OK) {
+ LOG(ERROR) << "Failed to unmount " << installerTarget;
+ // Intentional continue to try to unmount the other bind mount
+ }
+ }
+
+ std::string androidTarget(
+ StringPrintf("/mnt/user/%d/%s/%d/Android", userId, label.c_str(), userId));
+
+ LOG(INFO) << "Unmounting " << androidTarget;
+ auto status = UnmountTree(androidTarget);
+ if (status != OK) {
+ return status;
+ }
+ LOG(INFO) << "Unmounted " << androidTarget;
+
+ return OK;
+}
+
+status_t EmulatedVolume::doMount() {
+ std::string label = getLabel();
+ bool isVisible = getMountFlags() & MountFlags::kVisible;
+
+ mSdcardFsDefault = StringPrintf("/mnt/runtime/default/%s", label.c_str());
+ mSdcardFsRead = StringPrintf("/mnt/runtime/read/%s", label.c_str());
+ mSdcardFsWrite = StringPrintf("/mnt/runtime/write/%s", label.c_str());
+ mSdcardFsFull = StringPrintf("/mnt/runtime/full/%s", label.c_str());
setInternalPath(mRawPath);
setPath(StringPrintf("/storage/%s", label.c_str()));
- if (fs_prepare_dir(mFuseDefault.c_str(), 0700, AID_ROOT, AID_ROOT) ||
- fs_prepare_dir(mFuseRead.c_str(), 0700, AID_ROOT, AID_ROOT) ||
- fs_prepare_dir(mFuseWrite.c_str(), 0700, AID_ROOT, AID_ROOT) ||
- fs_prepare_dir(mFuseFull.c_str(), 0700, AID_ROOT, AID_ROOT)) {
+ if (fs_prepare_dir(mSdcardFsDefault.c_str(), 0700, AID_ROOT, AID_ROOT) ||
+ fs_prepare_dir(mSdcardFsRead.c_str(), 0700, AID_ROOT, AID_ROOT) ||
+ fs_prepare_dir(mSdcardFsWrite.c_str(), 0700, AID_ROOT, AID_ROOT) ||
+ fs_prepare_dir(mSdcardFsFull.c_str(), 0700, AID_ROOT, AID_ROOT)) {
PLOG(ERROR) << getId() << " failed to create mount points";
return -errno;
}
- dev_t before = GetDevice(mFuseFull);
+ dev_t before = GetDevice(mSdcardFsFull);
- if (!(mFusePid = fork())) {
- // clang-format off
- if (execl(kFusePath, kFusePath,
- "-u", "1023", // AID_MEDIA_RW
- "-g", "1023", // AID_MEDIA_RW
- "-m",
- "-w",
- "-G",
- "-i",
- "-o",
- mRawPath.c_str(),
- label.c_str(),
- NULL)) {
- // clang-format on
- PLOG(ERROR) << "Failed to exec";
+ bool isFuse = base::GetBoolProperty(kPropFuse, false);
+
+ // Mount sdcardfs regardless of FUSE, since we need it to bind-mount on top of the
+ // FUSE volume for various reasons.
+ if (mUseSdcardFs && getMountUserId() == 0) {
+ LOG(INFO) << "Executing sdcardfs";
+ int sdcardFsPid;
+ if (!(sdcardFsPid = fork())) {
+ // clang-format off
+ if (execl(kSdcardFsPath, kSdcardFsPath,
+ "-u", "1023", // AID_MEDIA_RW
+ "-g", "1023", // AID_MEDIA_RW
+ "-m",
+ "-w",
+ "-G",
+ "-i",
+ "-o",
+ mRawPath.c_str(),
+ label.c_str(),
+ NULL)) {
+ // clang-format on
+ PLOG(ERROR) << "Failed to exec";
+ }
+
+ LOG(ERROR) << "sdcardfs exiting";
+ _exit(1);
}
- LOG(ERROR) << "FUSE exiting";
- _exit(1);
- }
-
- if (mFusePid == -1) {
- PLOG(ERROR) << getId() << " failed to fork";
- return -errno;
- }
-
- nsecs_t start = systemTime(SYSTEM_TIME_BOOTTIME);
- while (before == GetDevice(mFuseFull)) {
- LOG(DEBUG) << "Waiting for FUSE to spin up...";
- usleep(50000); // 50ms
-
- nsecs_t now = systemTime(SYSTEM_TIME_BOOTTIME);
- if (nanoseconds_to_milliseconds(now - start) > 5000) {
- LOG(WARNING) << "Timed out while waiting for FUSE to spin up";
- return -ETIMEDOUT;
+ if (sdcardFsPid == -1) {
+ PLOG(ERROR) << getId() << " failed to fork";
+ return -errno;
}
+
+ nsecs_t start = systemTime(SYSTEM_TIME_BOOTTIME);
+ while (before == GetDevice(mSdcardFsFull)) {
+ LOG(DEBUG) << "Waiting for sdcardfs to spin up...";
+ usleep(50000); // 50ms
+
+ nsecs_t now = systemTime(SYSTEM_TIME_BOOTTIME);
+ if (nanoseconds_to_milliseconds(now - start) > 5000) {
+ LOG(WARNING) << "Timed out while waiting for sdcardfs to spin up";
+ return -ETIMEDOUT;
+ }
+ }
+ /* sdcardfs will have exited already. The filesystem will still be running */
+ TEMP_FAILURE_RETRY(waitpid(sdcardFsPid, nullptr, 0));
+ sdcardFsPid = 0;
}
- /* sdcardfs will have exited already. FUSE will still be running */
- TEMP_FAILURE_RETRY(waitpid(mFusePid, nullptr, 0));
- mFusePid = 0;
+ if (isFuse && isVisible) {
+ LOG(INFO) << "Mounting emulated fuse volume";
+ android::base::unique_fd fd;
+ int user_id = getMountUserId();
+ auto volumeRoot = getRootPath();
+
+ // Make sure Android/ dirs exist for bind mounting
+ status_t res = PrepareAndroidDirs(volumeRoot);
+ if (res != OK) {
+ LOG(ERROR) << "Failed to prepare Android/ directories";
+ return res;
+ }
+
+ res = MountUserFuse(user_id, getInternalPath(), label, &fd);
+ if (res != 0) {
+ PLOG(ERROR) << "Failed to mount emulated fuse volume";
+ return res;
+ }
+
+ mFuseMounted = true;
+ auto callback = getMountCallback();
+ if (callback) {
+ bool is_ready = false;
+ callback->onVolumeChecking(std::move(fd), getPath(), getInternalPath(), &is_ready);
+ if (!is_ready) {
+ fd.reset();
+ doUnmount();
+ return -EIO;
+ }
+ }
+
+ // Only do the bind-mounts when we know for sure the FUSE daemon can resolve the path.
+ res = mountFuseBindMounts();
+ if (res != OK) {
+ fd.reset();
+ doUnmount();
+ }
+ return res;
+ }
return OK;
}
status_t EmulatedVolume::doUnmount() {
- // Unmount the storage before we kill the FUSE process. If we kill
- // the FUSE process first, most file system operations will return
+ int userId = getMountUserId();
+
+ // Kill all processes using the filesystem before we unmount it. If we
+ // unmount the filesystem first, most file system operations will return
// ENOTCONN until the unmount completes. This is an exotic and unusual
// error code and might cause broken behaviour in applications.
- KillProcessesUsingPath(getPath());
- ForceUnmount(mFuseDefault);
- ForceUnmount(mFuseRead);
- ForceUnmount(mFuseWrite);
- ForceUnmount(mFuseFull);
+ if (mFuseMounted) {
+ // For FUSE specifically, we have an emulated volume per user, so only kill
+ // processes using files from this particular user.
+ std::string user_path(StringPrintf("%s/%d", getPath().c_str(), getMountUserId()));
+ LOG(INFO) << "Killing all processes referencing " << user_path;
+ KillProcessesUsingPath(user_path);
+ } else {
+ KillProcessesUsingPath(getPath());
+ }
- rmdir(mFuseDefault.c_str());
- rmdir(mFuseRead.c_str());
- rmdir(mFuseWrite.c_str());
- rmdir(mFuseFull.c_str());
+ if (mFuseMounted) {
+ std::string label = getLabel();
+ // Ignoring unmount return status because we do want to try to unmount
+ // the rest cleanly.
- mFuseDefault.clear();
- mFuseRead.clear();
- mFuseWrite.clear();
- mFuseFull.clear();
+ unmountFuseBindMounts();
+ if (UnmountUserFuse(userId, getInternalPath(), label) != OK) {
+ PLOG(INFO) << "UnmountUserFuse failed on emulated fuse volume";
+ return -errno;
+ }
+
+ mFuseMounted = false;
+ }
+ if (getMountUserId() != 0 || !mUseSdcardFs) {
+ // For sdcardfs, only unmount for user 0, since user 0 will always be running
+ // and the paths don't change for different users.
+ return OK;
+ }
+
+ ForceUnmount(mSdcardFsDefault);
+ ForceUnmount(mSdcardFsRead);
+ ForceUnmount(mSdcardFsWrite);
+ ForceUnmount(mSdcardFsFull);
+
+ rmdir(mSdcardFsDefault.c_str());
+ rmdir(mSdcardFsRead.c_str());
+ rmdir(mSdcardFsWrite.c_str());
+ rmdir(mSdcardFsFull.c_str());
+
+ mSdcardFsDefault.clear();
+ mSdcardFsRead.clear();
+ mSdcardFsWrite.clear();
+ mSdcardFsFull.clear();
return OK;
}
+std::string EmulatedVolume::getRootPath() const {
+ int user_id = getMountUserId();
+ std::string volumeRoot = StringPrintf("%s/%d", getInternalPath().c_str(), user_id);
+
+ return volumeRoot;
+}
+
} // namespace vold
} // namespace android
diff --git a/model/EmulatedVolume.h b/model/EmulatedVolume.h
index fddfe4e..3f1b2e3 100644
--- a/model/EmulatedVolume.h
+++ b/model/EmulatedVolume.h
@@ -27,7 +27,7 @@
/*
* Shared storage emulated on top of private storage.
*
- * Knows how to spawn a FUSE daemon to synthesize permissions. ObbVolume
+ * Knows how to spawn a sdcardfs daemon to synthesize permissions. ObbVolume
* can be stacked above it.
*
* This volume is always multi-user aware, but is only binds itself to
@@ -37,25 +37,33 @@
*/
class EmulatedVolume : public VolumeBase {
public:
- explicit EmulatedVolume(const std::string& rawPath);
- EmulatedVolume(const std::string& rawPath, dev_t device, const std::string& fsUuid);
+ explicit EmulatedVolume(const std::string& rawPath, int userId);
+ EmulatedVolume(const std::string& rawPath, dev_t device, const std::string& fsUuid, int userId);
virtual ~EmulatedVolume();
+ std::string getRootPath() const override;
protected:
status_t doMount() override;
status_t doUnmount() override;
private:
+ status_t mountFuseBindMounts();
+ status_t unmountFuseBindMounts();
+
+ std::string getLabel();
std::string mRawPath;
std::string mLabel;
- std::string mFuseDefault;
- std::string mFuseRead;
- std::string mFuseWrite;
- std::string mFuseFull;
+ std::string mSdcardFsDefault;
+ std::string mSdcardFsRead;
+ std::string mSdcardFsWrite;
+ std::string mSdcardFsFull;
- /* PID of FUSE wrapper */
- pid_t mFusePid;
+ /* Whether we mounted FUSE for this volume */
+ bool mFuseMounted;
+
+ /* Whether to use sdcardfs for this volume */
+ bool mUseSdcardFs;
DISALLOW_COPY_AND_ASSIGN(EmulatedVolume);
};
diff --git a/model/PrivateVolume.cpp b/model/PrivateVolume.cpp
index 4a0b250..9f1f089 100644
--- a/model/PrivateVolume.cpp
+++ b/model/PrivateVolume.cpp
@@ -154,12 +154,18 @@
return -EIO;
}
- // Create a new emulated volume stacked above us, it will automatically
- // be destroyed during unmount
+ auto vol_manager = VolumeManager::Instance();
std::string mediaPath(mPath + "/media");
- auto vol = std::shared_ptr<VolumeBase>(new EmulatedVolume(mediaPath, mRawDevice, mFsUuid));
- addVolume(vol);
- vol->create();
+
+ // Create a new emulated volume stacked above us for all added users, they will automatically
+ // be destroyed during unmount
+ for (userid_t user : vol_manager->getStartedUsers()) {
+ auto vol = std::shared_ptr<VolumeBase>(
+ new EmulatedVolume(mediaPath, mRawDevice, mFsUuid, user));
+ vol->setMountUserId(user);
+ addVolume(vol);
+ vol->create();
+ }
return OK;
}
diff --git a/model/PrivateVolume.h b/model/PrivateVolume.h
index 819632b..9780485 100644
--- a/model/PrivateVolume.h
+++ b/model/PrivateVolume.h
@@ -42,6 +42,8 @@
const std::string& getFsType() const { return mFsType; };
const std::string& getRawDevPath() const { return mRawDevPath; };
const std::string& getRawDmDevPath() const { return mDmDevPath; };
+ const std::string& getFsUuid() const { return mFsUuid; };
+ dev_t getRawDevice() const { return mRawDevice; };
protected:
status_t doCreate() override;
diff --git a/model/PublicVolume.cpp b/model/PublicVolume.cpp
index 0a6b351..a0b3227 100644
--- a/model/PublicVolume.cpp
+++ b/model/PublicVolume.cpp
@@ -15,6 +15,8 @@
*/
#include "PublicVolume.h"
+
+#include "AppFuseUtil.h"
#include "Utils.h"
#include "VolumeManager.h"
#include "fs/Exfat.h"
@@ -41,13 +43,15 @@
namespace android {
namespace vold {
-static const char* kFusePath = "/system/bin/sdcard";
+static const char* kSdcardFsPath = "/system/bin/sdcard";
static const char* kAsecPath = "/mnt/secure/asec";
-PublicVolume::PublicVolume(dev_t device) : VolumeBase(Type::kPublic), mDevice(device), mFusePid(0) {
+PublicVolume::PublicVolume(dev_t device) : VolumeBase(Type::kPublic), mDevice(device) {
setId(StringPrintf("public:%u,%u", major(device), minor(device)));
mDevPath = StringPrintf("/dev/block/vold/%s", getId().c_str());
+ mFuseMounted = false;
+ mUseSdcardFs = IsFilesystemSupported("sdcardfs");
}
PublicVolume::~PublicVolume() {}
@@ -93,6 +97,7 @@
}
status_t PublicVolume::doMount() {
+ bool isVisible = getMountFlags() & MountFlags::kVisible;
readMetadata();
if (mFsType == "vfat" && vfat::IsSupported()) {
@@ -118,13 +123,13 @@
mRawPath = StringPrintf("/mnt/media_rw/%s", stableName.c_str());
- mFuseDefault = StringPrintf("/mnt/runtime/default/%s", stableName.c_str());
- mFuseRead = StringPrintf("/mnt/runtime/read/%s", stableName.c_str());
- mFuseWrite = StringPrintf("/mnt/runtime/write/%s", stableName.c_str());
- mFuseFull = StringPrintf("/mnt/runtime/full/%s", stableName.c_str());
+ mSdcardFsDefault = StringPrintf("/mnt/runtime/default/%s", stableName.c_str());
+ mSdcardFsRead = StringPrintf("/mnt/runtime/read/%s", stableName.c_str());
+ mSdcardFsWrite = StringPrintf("/mnt/runtime/write/%s", stableName.c_str());
+ mSdcardFsFull = StringPrintf("/mnt/runtime/full/%s", stableName.c_str());
setInternalPath(mRawPath);
- if (getMountFlags() & MountFlags::kVisible) {
+ if (isVisible) {
setPath(StringPrintf("/storage/%s", stableName.c_str()));
} else {
setPath(mRawPath);
@@ -136,13 +141,14 @@
}
if (mFsType == "vfat") {
- if (vfat::Mount(mDevPath, mRawPath, false, false, false, AID_MEDIA_RW, AID_MEDIA_RW, 0007,
- true)) {
+ if (vfat::Mount(mDevPath, mRawPath, false, false, false, AID_ROOT,
+ (isVisible ? AID_MEDIA_RW : AID_EXTERNAL_STORAGE), 0007, true)) {
PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
return -EIO;
}
} else if (mFsType == "exfat") {
- if (exfat::Mount(mDevPath, mRawPath, AID_MEDIA_RW, AID_MEDIA_RW, 0007)) {
+ if (exfat::Mount(mDevPath, mRawPath, AID_ROOT,
+ (isVisible ? AID_MEDIA_RW : AID_EXTERNAL_STORAGE), 0007)) {
PLOG(ERROR) << getId() << " failed to mount " << mDevPath;
return -EIO;
}
@@ -152,72 +158,99 @@
initAsecStage();
}
- if (!(getMountFlags() & MountFlags::kVisible)) {
- // Not visible to apps, so no need to spin up FUSE
+ if (!isVisible) {
+ // Not visible to apps, so no need to spin up sdcardfs or FUSE
return OK;
}
- if (fs_prepare_dir(mFuseDefault.c_str(), 0700, AID_ROOT, AID_ROOT) ||
- fs_prepare_dir(mFuseRead.c_str(), 0700, AID_ROOT, AID_ROOT) ||
- fs_prepare_dir(mFuseWrite.c_str(), 0700, AID_ROOT, AID_ROOT) ||
- fs_prepare_dir(mFuseFull.c_str(), 0700, AID_ROOT, AID_ROOT)) {
- PLOG(ERROR) << getId() << " failed to create FUSE mount points";
- return -errno;
- }
-
- dev_t before = GetDevice(mFuseFull);
-
- if (!(mFusePid = fork())) {
- if (getMountFlags() & MountFlags::kPrimary) {
- // clang-format off
- if (execl(kFusePath, kFusePath,
- "-u", "1023", // AID_MEDIA_RW
- "-g", "1023", // AID_MEDIA_RW
- "-U", std::to_string(getMountUserId()).c_str(),
- "-w",
- mRawPath.c_str(),
- stableName.c_str(),
- NULL)) {
- // clang-format on
- PLOG(ERROR) << "Failed to exec";
- }
- } else {
- // clang-format off
- if (execl(kFusePath, kFusePath,
- "-u", "1023", // AID_MEDIA_RW
- "-g", "1023", // AID_MEDIA_RW
- "-U", std::to_string(getMountUserId()).c_str(),
- mRawPath.c_str(),
- stableName.c_str(),
- NULL)) {
- // clang-format on
- PLOG(ERROR) << "Failed to exec";
- }
+ if (mUseSdcardFs) {
+ if (fs_prepare_dir(mSdcardFsDefault.c_str(), 0700, AID_ROOT, AID_ROOT) ||
+ fs_prepare_dir(mSdcardFsRead.c_str(), 0700, AID_ROOT, AID_ROOT) ||
+ fs_prepare_dir(mSdcardFsWrite.c_str(), 0700, AID_ROOT, AID_ROOT) ||
+ fs_prepare_dir(mSdcardFsFull.c_str(), 0700, AID_ROOT, AID_ROOT)) {
+ PLOG(ERROR) << getId() << " failed to create sdcardfs mount points";
+ return -errno;
}
- LOG(ERROR) << "FUSE exiting";
- _exit(1);
+ dev_t before = GetDevice(mSdcardFsFull);
+
+ int sdcardFsPid;
+ if (!(sdcardFsPid = fork())) {
+ if (getMountFlags() & MountFlags::kPrimary) {
+ // clang-format off
+ if (execl(kSdcardFsPath, kSdcardFsPath,
+ "-u", "1023", // AID_MEDIA_RW
+ "-g", "1023", // AID_MEDIA_RW
+ "-U", std::to_string(getMountUserId()).c_str(),
+ "-w",
+ mRawPath.c_str(),
+ stableName.c_str(),
+ NULL)) {
+ // clang-format on
+ PLOG(ERROR) << "Failed to exec";
+ }
+ } else {
+ // clang-format off
+ if (execl(kSdcardFsPath, kSdcardFsPath,
+ "-u", "1023", // AID_MEDIA_RW
+ "-g", "1023", // AID_MEDIA_RW
+ "-U", std::to_string(getMountUserId()).c_str(),
+ mRawPath.c_str(),
+ stableName.c_str(),
+ NULL)) {
+ // clang-format on
+ PLOG(ERROR) << "Failed to exec";
+ }
+ }
+
+ LOG(ERROR) << "sdcardfs exiting";
+ _exit(1);
+ }
+
+ if (sdcardFsPid == -1) {
+ PLOG(ERROR) << getId() << " failed to fork";
+ return -errno;
+ }
+
+ nsecs_t start = systemTime(SYSTEM_TIME_BOOTTIME);
+ while (before == GetDevice(mSdcardFsFull)) {
+ LOG(DEBUG) << "Waiting for sdcardfs to spin up...";
+ usleep(50000); // 50ms
+
+ nsecs_t now = systemTime(SYSTEM_TIME_BOOTTIME);
+ if (nanoseconds_to_milliseconds(now - start) > 5000) {
+ LOG(WARNING) << "Timed out while waiting for sdcardfs to spin up";
+ return -ETIMEDOUT;
+ }
+ }
+ /* sdcardfs will have exited already. The filesystem will still be running */
+ TEMP_FAILURE_RETRY(waitpid(sdcardFsPid, nullptr, 0));
}
- if (mFusePid == -1) {
- PLOG(ERROR) << getId() << " failed to fork";
- return -errno;
- }
+ bool isFuse = base::GetBoolProperty(kPropFuse, false);
+ if (isFuse) {
+ // We need to mount FUSE *after* sdcardfs, since the FUSE daemon may depend
+ // on sdcardfs being up.
+ LOG(INFO) << "Mounting public fuse volume";
+ android::base::unique_fd fd;
+ int user_id = getMountUserId();
+ int result = MountUserFuse(user_id, getInternalPath(), stableName, &fd);
- nsecs_t start = systemTime(SYSTEM_TIME_BOOTTIME);
- while (before == GetDevice(mFuseFull)) {
- LOG(DEBUG) << "Waiting for FUSE to spin up...";
- usleep(50000); // 50ms
+ if (result != 0) {
+ LOG(ERROR) << "Failed to mount public fuse volume";
+ return -result;
+ }
- nsecs_t now = systemTime(SYSTEM_TIME_BOOTTIME);
- if (nanoseconds_to_milliseconds(now - start) > 5000) {
- LOG(WARNING) << "Timed out while waiting for FUSE to spin up";
- return -ETIMEDOUT;
+ mFuseMounted = true;
+ auto callback = getMountCallback();
+ if (callback) {
+ bool is_ready = false;
+ callback->onVolumeChecking(std::move(fd), getPath(), getInternalPath(), &is_ready);
+ if (!is_ready) {
+ return -EIO;
+ }
}
}
- /* sdcardfs will have exited already. FUSE will still be running */
- TEMP_FAILURE_RETRY(waitpid(mFusePid, nullptr, 0));
- mFusePid = 0;
return OK;
}
@@ -229,24 +262,41 @@
// error code and might cause broken behaviour in applications.
KillProcessesUsingPath(getPath());
+ if (mFuseMounted) {
+ // Use UUID as stable name, if available
+ std::string stableName = getId();
+ if (!mFsUuid.empty()) {
+ stableName = mFsUuid;
+ }
+
+ if (UnmountUserFuse(getMountUserId(), getInternalPath(), stableName) != OK) {
+ PLOG(INFO) << "UnmountUserFuse failed on public fuse volume";
+ return -errno;
+ }
+
+ mFuseMounted = false;
+ }
+
ForceUnmount(kAsecPath);
- ForceUnmount(mFuseDefault);
- ForceUnmount(mFuseRead);
- ForceUnmount(mFuseWrite);
- ForceUnmount(mFuseFull);
+ if (mUseSdcardFs) {
+ ForceUnmount(mSdcardFsDefault);
+ ForceUnmount(mSdcardFsRead);
+ ForceUnmount(mSdcardFsWrite);
+ ForceUnmount(mSdcardFsFull);
+
+ rmdir(mSdcardFsDefault.c_str());
+ rmdir(mSdcardFsRead.c_str());
+ rmdir(mSdcardFsWrite.c_str());
+ rmdir(mSdcardFsFull.c_str());
+
+ mSdcardFsDefault.clear();
+ mSdcardFsRead.clear();
+ mSdcardFsWrite.clear();
+ mSdcardFsFull.clear();
+ }
ForceUnmount(mRawPath);
-
- rmdir(mFuseDefault.c_str());
- rmdir(mFuseRead.c_str());
- rmdir(mFuseWrite.c_str());
- rmdir(mFuseFull.c_str());
rmdir(mRawPath.c_str());
-
- mFuseDefault.clear();
- mFuseRead.clear();
- mFuseWrite.clear();
- mFuseFull.clear();
mRawPath.clear();
return OK;
diff --git a/model/PublicVolume.h b/model/PublicVolume.h
index 2feccca..3156b53 100644
--- a/model/PublicVolume.h
+++ b/model/PublicVolume.h
@@ -27,7 +27,7 @@
/*
* Shared storage provided by public (vfat) partition.
*
- * Knows how to mount itself and then spawn a FUSE daemon to synthesize
+ * Knows how to mount itself and then spawn a sdcardfs daemon to synthesize
* permissions. AsecVolume and ObbVolume can be stacked above it.
*
* This volume is not inherently multi-user aware, so it has two possible
@@ -60,13 +60,16 @@
/* Mount point of raw partition */
std::string mRawPath;
- std::string mFuseDefault;
- std::string mFuseRead;
- std::string mFuseWrite;
- std::string mFuseFull;
+ std::string mSdcardFsDefault;
+ std::string mSdcardFsRead;
+ std::string mSdcardFsWrite;
+ std::string mSdcardFsFull;
- /* PID of FUSE wrapper */
- pid_t mFusePid;
+ /* Whether we mounted FUSE for this volume */
+ bool mFuseMounted;
+
+ /* Whether to use sdcardfs for this volume */
+ bool mUseSdcardFs;
/* Filesystem type */
std::string mFsType;
diff --git a/model/StubVolume.cpp b/model/StubVolume.cpp
index edd0861..d2cd8a8 100644
--- a/model/StubVolume.cpp
+++ b/model/StubVolume.cpp
@@ -16,6 +16,8 @@
#include "StubVolume.h"
+#include <inttypes.h>
+
#include <android-base/logging.h>
#include <android-base/stringprintf.h>
@@ -24,7 +26,7 @@
namespace android {
namespace vold {
-StubVolume::StubVolume(int id, const std::string& sourcePath, const std::string& mountPath,
+StubVolume::StubVolume(dev_t id, const std::string& sourcePath, const std::string& mountPath,
const std::string& fsType, const std::string& fsUuid,
const std::string& fsLabel)
: VolumeBase(Type::kStub),
@@ -33,7 +35,7 @@
mFsType(fsType),
mFsUuid(fsUuid),
mFsLabel(fsLabel) {
- setId(StringPrintf("stub:%d", id));
+ setId(StringPrintf("stub:%llu", (unsigned long long)id));
}
StubVolume::~StubVolume() {}
diff --git a/model/StubVolume.h b/model/StubVolume.h
index 538cae9..3697b53 100644
--- a/model/StubVolume.h
+++ b/model/StubVolume.h
@@ -31,7 +31,7 @@
*/
class StubVolume : public VolumeBase {
public:
- StubVolume(int id, const std::string& sourcePath, const std::string& mountPath,
+ StubVolume(dev_t id, const std::string& sourcePath, const std::string& mountPath,
const std::string& fsType, const std::string& fsUuid, const std::string& fsLabel);
virtual ~StubVolume();
diff --git a/model/VolumeBase.cpp b/model/VolumeBase.cpp
index ffc7900..687d4f7 100644
--- a/model/VolumeBase.cpp
+++ b/model/VolumeBase.cpp
@@ -143,6 +143,16 @@
return OK;
}
+status_t VolumeBase::setMountCallback(
+ const android::sp<android::os::IVoldMountCallback>& callback) {
+ mMountCallback = callback;
+ return OK;
+}
+
+sp<android::os::IVoldMountCallback> VolumeBase::getMountCallback() const {
+ return mMountCallback;
+}
+
android::sp<android::os::IVoldListener> VolumeBase::getListener() const {
if (mSilent) {
return nullptr;
@@ -176,7 +186,8 @@
auto listener = getListener();
if (listener) {
- listener->onVolumeCreated(getId(), static_cast<int32_t>(mType), mDiskId, mPartGuid);
+ listener->onVolumeCreated(getId(), static_cast<int32_t>(mType), mDiskId, mPartGuid,
+ mMountUserId);
}
setState(State::kUnmounted);
@@ -263,6 +274,11 @@
return -ENOTSUP;
}
+std::string VolumeBase::getRootPath() const {
+ // Usually the same as the internal path, except for emulated volumes.
+ return getInternalPath();
+}
+
std::ostream& VolumeBase::operator<<(std::ostream& stream) const {
return stream << " VolumeBase{id=" << mId << ",mountFlags=" << mMountFlags
<< ",mountUserId=" << mMountUserId << "}";
diff --git a/model/VolumeBase.h b/model/VolumeBase.h
index 53eeb6f..078bb0c 100644
--- a/model/VolumeBase.h
+++ b/model/VolumeBase.h
@@ -19,6 +19,7 @@
#include "Utils.h"
#include "android/os/IVoldListener.h"
+#include "android/os/IVoldMountCallback.h"
#include <cutils/multiuser.h>
#include <utils/Errors.h>
@@ -87,11 +88,13 @@
State getState() const { return mState; }
const std::string& getPath() const { return mPath; }
const std::string& getInternalPath() const { return mInternalPath; }
+ const std::list<std::shared_ptr<VolumeBase>>& getVolumes() const { return mVolumes; }
status_t setDiskId(const std::string& diskId);
status_t setPartGuid(const std::string& partGuid);
status_t setMountFlags(int mountFlags);
status_t setMountUserId(userid_t mountUserId);
+ status_t setMountCallback(const android::sp<android::os::IVoldMountCallback>& callback);
status_t setSilent(bool silent);
void addVolume(const std::shared_ptr<VolumeBase>& volume);
@@ -107,6 +110,8 @@
status_t unmount();
status_t format(const std::string& fsType);
+ virtual std::string getRootPath() const;
+
std::ostream& operator<<(std::ostream& stream) const;
protected:
@@ -123,6 +128,7 @@
status_t setInternalPath(const std::string& internalPath);
android::sp<android::os::IVoldListener> getListener() const;
+ android::sp<android::os::IVoldMountCallback> getMountCallback() const;
private:
/* ID that uniquely references volume while alive */
@@ -147,6 +153,7 @@
std::string mInternalPath;
/* Flag indicating that volume should emit no events */
bool mSilent;
+ android::sp<android::os::IVoldMountCallback> mMountCallback;
/* Volumes stacked on top of this volume */
std::list<std::shared_ptr<VolumeBase>> mVolumes;