1 // Copyright (C) 2016 The Android Open Source Project 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 #define LOG_TAG "sdcard" 16 17 #include <dirent.h> 18 #include <errno.h> 19 #include <fcntl.h> 20 #include <linux/fuse.h> 21 #include <pthread.h> 22 #include <stdlib.h> 23 #include <string.h> 24 #include <sys/inotify.h> 25 #include <sys/mount.h> 26 #include <sys/resource.h> 27 #include <sys/stat.h> 28 #include <sys/types.h> 29 #include <unistd.h> 30 #include <vector> 31 32 #include <android-base/file.h> 33 #include <android-base/logging.h> 34 #include <android-base/macros.h> 35 #include <android-base/stringprintf.h> 36 #include <android-base/strings.h> 37 38 #include <cutils/fs.h> 39 #include <cutils/multiuser.h> 40 #include <cutils/properties.h> 41 42 #include <libminijail.h> 43 #include <scoped_minijail.h> 44 45 #include <private/android_filesystem_config.h> 46 47 #define PROP_SDCARDFS_DEVICE "ro.sys.sdcardfs" 48 #define PROP_SDCARDFS_USER "persist.sys.sdcardfs" 49 50 static bool supports_esdfs(void) { 51 std::string filesystems; 52 if (!android::base::ReadFileToString("/proc/filesystems", &filesystems)) { 53 PLOG(ERROR) << "Could not read /proc/filesystems"; 54 return false; 55 } 56 for (const auto& fs : android::base::Split(filesystems, "\n")) { 57 if (fs.find("esdfs") != std::string::npos) return true; 58 } 59 return false; 60 } 61 62 static bool should_use_sdcardfs(void) { 63 char property[PROPERTY_VALUE_MAX]; 64 65 // Allow user to have a strong opinion about state 66 property_get(PROP_SDCARDFS_USER, property, ""); 67 if (!strcmp(property, "force_on")) { 68 LOG(WARNING) << "User explicitly enabled sdcardfs"; 69 return true; 70 } else if (!strcmp(property, "force_off")) { 71 LOG(WARNING) << "User explicitly disabled sdcardfs"; 72 return !supports_esdfs(); 73 } 74 75 // Fall back to device opinion about state 76 if (property_get_bool(PROP_SDCARDFS_DEVICE, true)) { 77 LOG(WARNING) << "Device explicitly enabled sdcardfs"; 78 return true; 79 } else { 80 LOG(WARNING) << "Device explicitly disabled sdcardfs"; 81 return !supports_esdfs(); 82 } 83 } 84 85 // NOTE: This is a vestigial program that simply exists to mount the in-kernel 86 // sdcardfs filesystem. The older FUSE-based design that used to live here has 87 // been completely removed to avoid confusion. 88 89 /* Supplementary groups to execute with. */ 90 static const gid_t kGroups[1] = { AID_PACKAGE_INFO }; 91 92 static void drop_privs(uid_t uid, gid_t gid) { 93 ScopedMinijail j(minijail_new()); 94 minijail_set_supplementary_gids(j.get(), arraysize(kGroups), kGroups); 95 minijail_change_gid(j.get(), gid); 96 minijail_change_uid(j.get(), uid); 97 /* minijail_enter() will abort if priv-dropping fails. */ 98 minijail_enter(j.get()); 99 } 100 101 static bool sdcardfs_setup(const std::string& source_path, const std::string& dest_path, 102 uid_t fsuid, gid_t fsgid, bool multi_user, userid_t userid, gid_t gid, 103 mode_t mask, bool derive_gid, bool default_normal, bool unshared_obb, 104 bool use_esdfs) { 105 // Add new options at the end of the vector. 106 std::vector<std::string> new_opts_list; 107 if (multi_user) new_opts_list.push_back("multiuser,"); 108 if (derive_gid) new_opts_list.push_back("derive_gid,"); 109 if (default_normal) new_opts_list.push_back("default_normal,"); 110 if (unshared_obb) new_opts_list.push_back("unshared_obb,"); 111 // Try several attempts, each time with one less option, to gracefully 112 // handle older kernels that aren't updated yet. 113 for (int i = 0; i <= new_opts_list.size(); ++i) { 114 std::string new_opts; 115 for (int j = 0; j < new_opts_list.size() - i; ++j) { 116 new_opts += new_opts_list[j]; 117 } 118 119 auto opts = android::base::StringPrintf("fsuid=%d,fsgid=%d,%smask=%d,userid=%d,gid=%d", 120 fsuid, fsgid, new_opts.c_str(), mask, userid, gid); 121 if (mount(source_path.c_str(), dest_path.c_str(), use_esdfs ? "esdfs" : "sdcardfs", 122 MS_NOSUID | MS_NODEV | MS_NOEXEC | MS_NOATIME, opts.c_str()) == -1) { 123 PLOG(WARNING) << "Failed to mount sdcardfs with options " << opts; 124 } else { 125 return true; 126 } 127 } 128 129 return false; 130 } 131 132 static bool sdcardfs_setup_bind_remount(const std::string& source_path, const std::string& dest_path, 133 gid_t gid, mode_t mask) { 134 std::string opts = android::base::StringPrintf("mask=%d,gid=%d", mask, gid); 135 136 if (mount(source_path.c_str(), dest_path.c_str(), nullptr, 137 MS_BIND, nullptr) != 0) { 138 PLOG(ERROR) << "failed to bind mount sdcardfs filesystem"; 139 return false; 140 } 141 142 if (mount(source_path.c_str(), dest_path.c_str(), "none", 143 MS_REMOUNT | MS_NOSUID | MS_NODEV | MS_NOEXEC | MS_NOATIME, opts.c_str()) != 0) { 144 PLOG(ERROR) << "failed to mount sdcardfs filesystem"; 145 if (umount2(dest_path.c_str(), MNT_DETACH)) 146 PLOG(WARNING) << "Failed to unmount bind"; 147 return false; 148 } 149 150 return true; 151 } 152 153 static bool sdcardfs_setup_secondary(const std::string& default_path, 154 const std::string& source_path, const std::string& dest_path, 155 uid_t fsuid, gid_t fsgid, bool multi_user, userid_t userid, 156 gid_t gid, mode_t mask, bool derive_gid, bool default_normal, 157 bool unshared_obb, bool use_esdfs) { 158 if (use_esdfs) { 159 return sdcardfs_setup(source_path, dest_path, fsuid, fsgid, multi_user, userid, gid, mask, 160 derive_gid, default_normal, unshared_obb, use_esdfs); 161 } else { 162 return sdcardfs_setup_bind_remount(default_path, dest_path, gid, mask); 163 } 164 } 165 166 static void run_sdcardfs(const std::string& source_path, const std::string& label, uid_t uid, 167 gid_t gid, userid_t userid, bool multi_user, bool full_write, 168 bool derive_gid, bool default_normal, bool unshared_obb, bool use_esdfs) { 169 std::string dest_path_default = "/mnt/runtime/default/" + label; 170 std::string dest_path_read = "/mnt/runtime/read/" + label; 171 std::string dest_path_write = "/mnt/runtime/write/" + label; 172 std::string dest_path_full = "/mnt/runtime/full/" + label; 173 174 umask(0); 175 if (multi_user) { 176 // Multi-user storage is fully isolated per user, so "other" 177 // permissions are completely masked off. 178 if (!sdcardfs_setup(source_path, dest_path_default, uid, gid, multi_user, userid, 179 AID_SDCARD_RW, 0006, derive_gid, default_normal, unshared_obb, 180 use_esdfs) || 181 !sdcardfs_setup_secondary(dest_path_default, source_path, dest_path_read, uid, gid, 182 multi_user, userid, AID_EVERYBODY, 0027, derive_gid, 183 default_normal, unshared_obb, use_esdfs) || 184 !sdcardfs_setup_secondary(dest_path_default, source_path, dest_path_write, uid, gid, 185 multi_user, userid, AID_EVERYBODY, full_write ? 0007 : 0027, 186 derive_gid, default_normal, unshared_obb, use_esdfs) || 187 !sdcardfs_setup_secondary(dest_path_default, source_path, dest_path_full, uid, gid, 188 multi_user, userid, AID_EVERYBODY, 0007, derive_gid, 189 default_normal, unshared_obb, use_esdfs)) { 190 LOG(FATAL) << "failed to sdcardfs_setup"; 191 } 192 } else { 193 // Physical storage is readable by all users on device, but 194 // the Android directories are masked off to a single user 195 // deep inside attr_from_stat(). 196 if (!sdcardfs_setup(source_path, dest_path_default, uid, gid, multi_user, userid, 197 AID_SDCARD_RW, 0006, derive_gid, default_normal, unshared_obb, 198 use_esdfs) || 199 !sdcardfs_setup_secondary(dest_path_default, source_path, dest_path_read, uid, gid, 200 multi_user, userid, AID_EVERYBODY, full_write ? 0027 : 0022, 201 derive_gid, default_normal, unshared_obb, use_esdfs) || 202 !sdcardfs_setup_secondary(dest_path_default, source_path, dest_path_write, uid, gid, 203 multi_user, userid, AID_EVERYBODY, full_write ? 0007 : 0022, 204 derive_gid, default_normal, unshared_obb, use_esdfs) || 205 !sdcardfs_setup_secondary(dest_path_default, source_path, dest_path_full, uid, gid, 206 multi_user, userid, AID_EVERYBODY, 0007, derive_gid, 207 default_normal, unshared_obb, use_esdfs)) { 208 LOG(FATAL) << "failed to sdcardfs_setup"; 209 } 210 } 211 212 // Will abort if priv-dropping fails. 213 drop_privs(uid, gid); 214 215 if (multi_user) { 216 std::string obb_path = source_path + "/obb"; 217 fs_prepare_dir(obb_path.c_str(), 0775, uid, gid); 218 } 219 220 exit(0); 221 } 222 223 static int usage() { 224 LOG(ERROR) << "usage: sdcard [OPTIONS] <source_path> <label>" 225 << " -u: specify UID to run as" 226 << " -g: specify GID to run as" 227 << " -U: specify user ID that owns device" 228 << " -m: source_path is multi-user" 229 << " -w: runtime write mount has full write access" 230 << " -P: preserve owners on the lower file system" 231 << " -o: obb dir doesn't need to be shared between users"; 232 return 1; 233 } 234 235 int main(int argc, char **argv) { 236 const char *source_path = NULL; 237 const char *label = NULL; 238 uid_t uid = 0; 239 gid_t gid = 0; 240 userid_t userid = 0; 241 bool multi_user = false; 242 bool full_write = false; 243 bool derive_gid = false; 244 bool default_normal = false; 245 bool unshared_obb = false; 246 int i; 247 struct rlimit rlim; 248 int fs_version; 249 250 setenv("ANDROID_LOG_TAGS", "*:v", 1); 251 android::base::InitLogging(argv, android::base::LogdLogger(android::base::SYSTEM)); 252 253 int opt; 254 while ((opt = getopt(argc, argv, "u:g:U:mwGio")) != -1) { 255 switch (opt) { 256 case 'u': 257 uid = strtoul(optarg, NULL, 10); 258 break; 259 case 'g': 260 gid = strtoul(optarg, NULL, 10); 261 break; 262 case 'U': 263 userid = strtoul(optarg, NULL, 10); 264 break; 265 case 'm': 266 multi_user = true; 267 break; 268 case 'w': 269 full_write = true; 270 break; 271 case 'G': 272 derive_gid = true; 273 break; 274 case 'i': 275 default_normal = true; 276 break; 277 case 'o': 278 unshared_obb = true; 279 break; 280 case '?': 281 default: 282 LOG(ERROR) << "Unknown option: '" << opt << "'"; 283 return usage(); 284 } 285 } 286 287 for (i = optind; i < argc; i++) { 288 char* arg = argv[i]; 289 if (!source_path) { 290 source_path = arg; 291 } else if (!label) { 292 label = arg; 293 } else { 294 LOG(ERROR) << "too many arguments"; 295 return usage(); 296 } 297 } 298 299 if (!source_path) { 300 LOG(ERROR) << "no source path specified"; 301 return usage(); 302 } 303 if (!label) { 304 LOG(ERROR) << "no label specified"; 305 return usage(); 306 } 307 if (!uid || !gid) { 308 LOG(ERROR) << "uid and gid must be nonzero"; 309 return usage(); 310 } 311 312 rlim.rlim_cur = 8192; 313 rlim.rlim_max = 8192; 314 if (setrlimit(RLIMIT_NOFILE, &rlim) == -1) { 315 PLOG(ERROR) << "setting RLIMIT_NOFILE failed"; 316 } 317 318 while ((fs_read_atomic_int("/data/misc/installd/layout_version", &fs_version) == -1) || 319 (fs_version < 3)) { 320 LOG(ERROR) << "installd fs upgrade not yet complete; waiting..."; 321 sleep(1); 322 } 323 324 run_sdcardfs(source_path, label, uid, gid, userid, multi_user, full_write, derive_gid, 325 default_normal, unshared_obb, !should_use_sdcardfs()); 326 return 1; 327 } 328