1 /*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <dirent.h>
18 #include <errno.h>
19 #include <fcntl.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <unistd.h>
24 #include <string>
25 #include <vector>
26
27 #include <sys/mman.h>
28 #include <sys/mount.h>
29 #include <sys/stat.h>
30 #include <sys/types.h>
31 #include <sys/wait.h>
32
33 #include <linux/kdev_t.h>
34
35 #include <android-base/logging.h>
36 #include <android-base/properties.h>
37 #include <android-base/stringprintf.h>
38 #include <cutils/properties.h>
39 #include <fscrypt/fscrypt.h>
40 #include <logwrap/logwrap.h>
41 #include <selinux/selinux.h>
42
43 #include "Ext4.h"
44 #include "FsCrypt.h"
45 #include "Utils.h"
46 #include "VoldUtil.h"
47
48 using android::base::StringPrintf;
49
50 namespace android {
51 namespace vold {
52 namespace ext4 {
53
54 static const char* kResizefsPath = "/system/bin/resize2fs";
55 static const char* kMkfsPath = "/system/bin/mke2fs";
56 static const char* kFsckPath = "/system/bin/e2fsck";
57
IsSupported()58 bool IsSupported() {
59 return access(kMkfsPath, X_OK) == 0 && access(kFsckPath, X_OK) == 0 &&
60 IsFilesystemSupported("ext4");
61 }
62
Check(const std::string & source,const std::string & target)63 status_t Check(const std::string& source, const std::string& target) {
64 // The following is shamelessly borrowed from fs_mgr.c, so it should be
65 // kept in sync with any changes over there.
66
67 const char* c_source = source.c_str();
68 const char* c_target = target.c_str();
69 int ret;
70 long tmpmnt_flags = MS_NOATIME | MS_NOEXEC | MS_NOSUID;
71 char* tmpmnt_opts = (char*)"nomblk_io_submit,errors=remount-ro";
72
73 /*
74 * First try to mount and unmount the filesystem. We do this because
75 * the kernel is more efficient than e2fsck in running the journal and
76 * processing orphaned inodes, and on at least one device with a
77 * performance issue in the emmc firmware, it can take e2fsck 2.5 minutes
78 * to do what the kernel does in about a second.
79 *
80 * After mounting and unmounting the filesystem, run e2fsck, and if an
81 * error is recorded in the filesystem superblock, e2fsck will do a full
82 * check. Otherwise, it does nothing. If the kernel cannot mount the
83 * filesytsem due to an error, e2fsck is still run to do a full check
84 * fix the filesystem.
85 */
86 ret = mount(c_source, c_target, "ext4", tmpmnt_flags, tmpmnt_opts);
87 if (!ret) {
88 int i;
89 for (i = 0; i < 5; i++) {
90 // Try to umount 5 times before continuing on.
91 // Should we try rebooting if all attempts fail?
92 int result = umount(c_target);
93 if (result == 0) {
94 break;
95 }
96 LOG(WARNING) << __func__ << "(): umount(" << c_target << ")=" << result << ": "
97 << strerror(errno);
98 sleep(1);
99 }
100 }
101
102 /*
103 * Some system images do not have e2fsck for licensing reasons
104 * (e.g. recent SDK system images). Detect these and skip the check.
105 */
106 if (access(kFsckPath, X_OK)) {
107 LOG(DEBUG) << "Not running " << kFsckPath << " on " << c_source
108 << " (executable not in system image)";
109 } else {
110 LOG(DEBUG) << "Running " << kFsckPath << " on " << c_source;
111
112 std::vector<std::string> cmd;
113 cmd.push_back(kFsckPath);
114 cmd.push_back("-y");
115 cmd.push_back(c_source);
116
117 // ext4 devices are currently always trusted
118 return ForkExecvp(cmd, nullptr, sFsckContext);
119 }
120
121 return 0;
122 }
123
Mount(const std::string & source,const std::string & target,bool ro,bool remount,bool executable)124 status_t Mount(const std::string& source, const std::string& target, bool ro, bool remount,
125 bool executable) {
126 int rc;
127 unsigned long flags;
128
129 const char* c_source = source.c_str();
130 const char* c_target = target.c_str();
131
132 flags = MS_NOATIME | MS_NODEV | MS_NOSUID | MS_DIRSYNC;
133
134 flags |= (executable ? 0 : MS_NOEXEC);
135 flags |= (ro ? MS_RDONLY : 0);
136 flags |= (remount ? MS_REMOUNT : 0);
137
138 rc = mount(c_source, c_target, "ext4", flags, NULL);
139
140 if (rc && errno == EROFS) {
141 LOG(ERROR) << source << " appears to be a read only filesystem - retrying mount RO";
142 flags |= MS_RDONLY;
143 rc = mount(c_source, c_target, "ext4", flags, NULL);
144 }
145
146 return rc;
147 }
148
Resize(const std::string & source,unsigned long numSectors)149 status_t Resize(const std::string& source, unsigned long numSectors) {
150 std::vector<std::string> cmd;
151 cmd.push_back(kResizefsPath);
152 cmd.push_back("-f");
153 cmd.push_back(source);
154 cmd.push_back(StringPrintf("%lu", numSectors));
155
156 return ForkExecvp(cmd);
157 }
158
Format(const std::string & source,unsigned long numSectors,const std::string & target)159 status_t Format(const std::string& source, unsigned long numSectors, const std::string& target) {
160 std::vector<std::string> cmd;
161 cmd.push_back(kMkfsPath);
162
163 cmd.push_back("-b");
164 cmd.push_back("4096");
165
166 cmd.push_back("-t");
167 cmd.push_back("ext4");
168
169 cmd.push_back("-M");
170 cmd.push_back(target);
171
172 bool needs_casefold =
173 android::base::GetBoolProperty("external_storage.casefold.enabled", false);
174 bool needs_projid = true;
175
176 if (needs_projid) {
177 cmd.push_back("-I");
178 cmd.push_back("512");
179 }
180
181 std::string options("has_journal");
182 if (android::base::GetBoolProperty("vold.has_quota", false)) {
183 options += ",quota";
184 }
185 if (IsFbeEnabled()) {
186 options += ",encrypt";
187 }
188 if (needs_casefold) {
189 options += ",casefold";
190 }
191
192 cmd.push_back("-O");
193 cmd.push_back(options);
194
195 if (needs_casefold || needs_projid) {
196 cmd.push_back("-E");
197 std::string extopts = "";
198 if (needs_casefold) extopts += "encoding=utf8,";
199 if (needs_projid) extopts += "quotatype=usrquota:grpquota:prjquota,";
200 cmd.push_back(extopts);
201 }
202
203 cmd.push_back(source);
204
205 if (numSectors) {
206 cmd.push_back(StringPrintf("%lu", numSectors * (4096 / 512)));
207 }
208
209 return ForkExecvp(cmd);
210 }
211
212 } // namespace ext4
213 } // namespace vold
214 } // namespace android
215