You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
328 lines
12 KiB
328 lines
12 KiB
// Copyright (C) 2016 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.
|
|
|
|
#define LOG_TAG "sdcard"
|
|
|
|
#include <dirent.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <linux/fuse.h>
|
|
#include <pthread.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/inotify.h>
|
|
#include <sys/mount.h>
|
|
#include <sys/resource.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#include <vector>
|
|
|
|
#include <android-base/file.h>
|
|
#include <android-base/logging.h>
|
|
#include <android-base/macros.h>
|
|
#include <android-base/stringprintf.h>
|
|
#include <android-base/strings.h>
|
|
|
|
#include <cutils/fs.h>
|
|
#include <cutils/multiuser.h>
|
|
#include <cutils/properties.h>
|
|
|
|
#include <libminijail.h>
|
|
#include <scoped_minijail.h>
|
|
|
|
#include <private/android_filesystem_config.h>
|
|
|
|
#define PROP_SDCARDFS_DEVICE "ro.sys.sdcardfs"
|
|
#define PROP_SDCARDFS_USER "persist.sys.sdcardfs"
|
|
|
|
static bool supports_esdfs(void) {
|
|
std::string filesystems;
|
|
if (!android::base::ReadFileToString("/proc/filesystems", &filesystems)) {
|
|
PLOG(ERROR) << "Could not read /proc/filesystems";
|
|
return false;
|
|
}
|
|
for (const auto& fs : android::base::Split(filesystems, "\n")) {
|
|
if (fs.find("esdfs") != std::string::npos) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool should_use_sdcardfs(void) {
|
|
char property[PROPERTY_VALUE_MAX];
|
|
|
|
// Allow user to have a strong opinion about state
|
|
property_get(PROP_SDCARDFS_USER, property, "");
|
|
if (!strcmp(property, "force_on")) {
|
|
LOG(WARNING) << "User explicitly enabled sdcardfs";
|
|
return true;
|
|
} else if (!strcmp(property, "force_off")) {
|
|
LOG(WARNING) << "User explicitly disabled sdcardfs";
|
|
return !supports_esdfs();
|
|
}
|
|
|
|
// Fall back to device opinion about state
|
|
if (property_get_bool(PROP_SDCARDFS_DEVICE, true)) {
|
|
LOG(WARNING) << "Device explicitly enabled sdcardfs";
|
|
return true;
|
|
} else {
|
|
LOG(WARNING) << "Device explicitly disabled sdcardfs";
|
|
return !supports_esdfs();
|
|
}
|
|
}
|
|
|
|
// NOTE: This is a vestigial program that simply exists to mount the in-kernel
|
|
// sdcardfs filesystem. The older FUSE-based design that used to live here has
|
|
// been completely removed to avoid confusion.
|
|
|
|
/* Supplementary groups to execute with. */
|
|
static const gid_t kGroups[1] = { AID_PACKAGE_INFO };
|
|
|
|
static void drop_privs(uid_t uid, gid_t gid) {
|
|
ScopedMinijail j(minijail_new());
|
|
minijail_set_supplementary_gids(j.get(), arraysize(kGroups), kGroups);
|
|
minijail_change_gid(j.get(), gid);
|
|
minijail_change_uid(j.get(), uid);
|
|
/* minijail_enter() will abort if priv-dropping fails. */
|
|
minijail_enter(j.get());
|
|
}
|
|
|
|
static bool sdcardfs_setup(const std::string& source_path, const std::string& dest_path,
|
|
uid_t fsuid, gid_t fsgid, bool multi_user, userid_t userid, gid_t gid,
|
|
mode_t mask, bool derive_gid, bool default_normal, bool unshared_obb,
|
|
bool use_esdfs) {
|
|
// Add new options at the end of the vector.
|
|
std::vector<std::string> new_opts_list;
|
|
if (multi_user) new_opts_list.push_back("multiuser,");
|
|
if (derive_gid) new_opts_list.push_back("derive_gid,");
|
|
if (default_normal) new_opts_list.push_back("default_normal,");
|
|
if (unshared_obb) new_opts_list.push_back("unshared_obb,");
|
|
// Try several attempts, each time with one less option, to gracefully
|
|
// handle older kernels that aren't updated yet.
|
|
for (int i = 0; i <= new_opts_list.size(); ++i) {
|
|
std::string new_opts;
|
|
for (int j = 0; j < new_opts_list.size() - i; ++j) {
|
|
new_opts += new_opts_list[j];
|
|
}
|
|
|
|
auto opts = android::base::StringPrintf("fsuid=%d,fsgid=%d,%smask=%d,userid=%d,gid=%d",
|
|
fsuid, fsgid, new_opts.c_str(), mask, userid, gid);
|
|
if (mount(source_path.c_str(), dest_path.c_str(), use_esdfs ? "esdfs" : "sdcardfs",
|
|
MS_NOSUID | MS_NODEV | MS_NOEXEC | MS_NOATIME, opts.c_str()) == -1) {
|
|
PLOG(WARNING) << "Failed to mount sdcardfs with options " << opts;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static bool sdcardfs_setup_bind_remount(const std::string& source_path, const std::string& dest_path,
|
|
gid_t gid, mode_t mask) {
|
|
std::string opts = android::base::StringPrintf("mask=%d,gid=%d", mask, gid);
|
|
|
|
if (mount(source_path.c_str(), dest_path.c_str(), nullptr,
|
|
MS_BIND, nullptr) != 0) {
|
|
PLOG(ERROR) << "failed to bind mount sdcardfs filesystem";
|
|
return false;
|
|
}
|
|
|
|
if (mount(source_path.c_str(), dest_path.c_str(), "none",
|
|
MS_REMOUNT | MS_NOSUID | MS_NODEV | MS_NOEXEC | MS_NOATIME, opts.c_str()) != 0) {
|
|
PLOG(ERROR) << "failed to mount sdcardfs filesystem";
|
|
if (umount2(dest_path.c_str(), MNT_DETACH))
|
|
PLOG(WARNING) << "Failed to unmount bind";
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool sdcardfs_setup_secondary(const std::string& default_path,
|
|
const std::string& source_path, const std::string& dest_path,
|
|
uid_t fsuid, gid_t fsgid, bool multi_user, userid_t userid,
|
|
gid_t gid, mode_t mask, bool derive_gid, bool default_normal,
|
|
bool unshared_obb, bool use_esdfs) {
|
|
if (use_esdfs) {
|
|
return sdcardfs_setup(source_path, dest_path, fsuid, fsgid, multi_user, userid, gid, mask,
|
|
derive_gid, default_normal, unshared_obb, use_esdfs);
|
|
} else {
|
|
return sdcardfs_setup_bind_remount(default_path, dest_path, gid, mask);
|
|
}
|
|
}
|
|
|
|
static void run_sdcardfs(const std::string& source_path, const std::string& label, uid_t uid,
|
|
gid_t gid, userid_t userid, bool multi_user, bool full_write,
|
|
bool derive_gid, bool default_normal, bool unshared_obb, bool use_esdfs) {
|
|
std::string dest_path_default = "/mnt/runtime/default/" + label;
|
|
std::string dest_path_read = "/mnt/runtime/read/" + label;
|
|
std::string dest_path_write = "/mnt/runtime/write/" + label;
|
|
std::string dest_path_full = "/mnt/runtime/full/" + label;
|
|
|
|
umask(0);
|
|
if (multi_user) {
|
|
// Multi-user storage is fully isolated per user, so "other"
|
|
// permissions are completely masked off.
|
|
if (!sdcardfs_setup(source_path, dest_path_default, uid, gid, multi_user, userid,
|
|
AID_SDCARD_RW, 0006, derive_gid, default_normal, unshared_obb,
|
|
use_esdfs) ||
|
|
!sdcardfs_setup_secondary(dest_path_default, source_path, dest_path_read, uid, gid,
|
|
multi_user, userid, AID_EVERYBODY, 0027, derive_gid,
|
|
default_normal, unshared_obb, use_esdfs) ||
|
|
!sdcardfs_setup_secondary(dest_path_default, source_path, dest_path_write, uid, gid,
|
|
multi_user, userid, AID_EVERYBODY, full_write ? 0007 : 0027,
|
|
derive_gid, default_normal, unshared_obb, use_esdfs) ||
|
|
!sdcardfs_setup_secondary(dest_path_default, source_path, dest_path_full, uid, gid,
|
|
multi_user, userid, AID_EVERYBODY, 0007, derive_gid,
|
|
default_normal, unshared_obb, use_esdfs)) {
|
|
LOG(FATAL) << "failed to sdcardfs_setup";
|
|
}
|
|
} else {
|
|
// Physical storage is readable by all users on device, but
|
|
// the Android directories are masked off to a single user
|
|
// deep inside attr_from_stat().
|
|
if (!sdcardfs_setup(source_path, dest_path_default, uid, gid, multi_user, userid,
|
|
AID_SDCARD_RW, 0006, derive_gid, default_normal, unshared_obb,
|
|
use_esdfs) ||
|
|
!sdcardfs_setup_secondary(dest_path_default, source_path, dest_path_read, uid, gid,
|
|
multi_user, userid, AID_EVERYBODY, full_write ? 0027 : 0022,
|
|
derive_gid, default_normal, unshared_obb, use_esdfs) ||
|
|
!sdcardfs_setup_secondary(dest_path_default, source_path, dest_path_write, uid, gid,
|
|
multi_user, userid, AID_EVERYBODY, full_write ? 0007 : 0022,
|
|
derive_gid, default_normal, unshared_obb, use_esdfs) ||
|
|
!sdcardfs_setup_secondary(dest_path_default, source_path, dest_path_full, uid, gid,
|
|
multi_user, userid, AID_EVERYBODY, 0007, derive_gid,
|
|
default_normal, unshared_obb, use_esdfs)) {
|
|
LOG(FATAL) << "failed to sdcardfs_setup";
|
|
}
|
|
}
|
|
|
|
// Will abort if priv-dropping fails.
|
|
drop_privs(uid, gid);
|
|
|
|
if (multi_user) {
|
|
std::string obb_path = source_path + "/obb";
|
|
fs_prepare_dir(obb_path.c_str(), 0775, uid, gid);
|
|
}
|
|
|
|
exit(0);
|
|
}
|
|
|
|
static int usage() {
|
|
LOG(ERROR) << "usage: sdcard [OPTIONS] <source_path> <label>"
|
|
<< " -u: specify UID to run as"
|
|
<< " -g: specify GID to run as"
|
|
<< " -U: specify user ID that owns device"
|
|
<< " -m: source_path is multi-user"
|
|
<< " -w: runtime write mount has full write access"
|
|
<< " -P: preserve owners on the lower file system"
|
|
<< " -o: obb dir doesn't need to be shared between users";
|
|
return 1;
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
const char *source_path = NULL;
|
|
const char *label = NULL;
|
|
uid_t uid = 0;
|
|
gid_t gid = 0;
|
|
userid_t userid = 0;
|
|
bool multi_user = false;
|
|
bool full_write = false;
|
|
bool derive_gid = false;
|
|
bool default_normal = false;
|
|
bool unshared_obb = false;
|
|
int i;
|
|
struct rlimit rlim;
|
|
int fs_version;
|
|
|
|
setenv("ANDROID_LOG_TAGS", "*:v", 1);
|
|
android::base::InitLogging(argv, android::base::LogdLogger(android::base::SYSTEM));
|
|
|
|
int opt;
|
|
while ((opt = getopt(argc, argv, "u:g:U:mwGio")) != -1) {
|
|
switch (opt) {
|
|
case 'u':
|
|
uid = strtoul(optarg, NULL, 10);
|
|
break;
|
|
case 'g':
|
|
gid = strtoul(optarg, NULL, 10);
|
|
break;
|
|
case 'U':
|
|
userid = strtoul(optarg, NULL, 10);
|
|
break;
|
|
case 'm':
|
|
multi_user = true;
|
|
break;
|
|
case 'w':
|
|
full_write = true;
|
|
break;
|
|
case 'G':
|
|
derive_gid = true;
|
|
break;
|
|
case 'i':
|
|
default_normal = true;
|
|
break;
|
|
case 'o':
|
|
unshared_obb = true;
|
|
break;
|
|
case '?':
|
|
default:
|
|
LOG(ERROR) << "Unknown option: '" << opt << "'";
|
|
return usage();
|
|
}
|
|
}
|
|
|
|
for (i = optind; i < argc; i++) {
|
|
char* arg = argv[i];
|
|
if (!source_path) {
|
|
source_path = arg;
|
|
} else if (!label) {
|
|
label = arg;
|
|
} else {
|
|
LOG(ERROR) << "too many arguments";
|
|
return usage();
|
|
}
|
|
}
|
|
|
|
if (!source_path) {
|
|
LOG(ERROR) << "no source path specified";
|
|
return usage();
|
|
}
|
|
if (!label) {
|
|
LOG(ERROR) << "no label specified";
|
|
return usage();
|
|
}
|
|
if (!uid || !gid) {
|
|
LOG(ERROR) << "uid and gid must be nonzero";
|
|
return usage();
|
|
}
|
|
|
|
rlim.rlim_cur = 8192;
|
|
rlim.rlim_max = 8192;
|
|
if (setrlimit(RLIMIT_NOFILE, &rlim) == -1) {
|
|
PLOG(ERROR) << "setting RLIMIT_NOFILE failed";
|
|
}
|
|
|
|
while ((fs_read_atomic_int("/data/misc/installd/layout_version", &fs_version) == -1) ||
|
|
(fs_version < 3)) {
|
|
LOG(ERROR) << "installd fs upgrade not yet complete; waiting...";
|
|
sleep(1);
|
|
}
|
|
|
|
run_sdcardfs(source_path, label, uid, gid, userid, multi_user, full_write, derive_gid,
|
|
default_normal, unshared_obb, !should_use_sdcardfs());
|
|
return 1;
|
|
}
|