1 /*
2 * Copyright (C) 2015 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 "IdleMaint.h"
18 #include "FileDeviceUtils.h"
19 #include "Utils.h"
20 #include "VolumeManager.h"
21 #include "model/PrivateVolume.h"
22
23 #include <thread>
24
25 #include <android-base/chrono_utils.h>
26 #include <android-base/file.h>
27 #include <android-base/logging.h>
28 #include <android-base/stringprintf.h>
29 #include <android-base/strings.h>
30 #include <android/hardware/health/storage/1.0/IStorage.h>
31 #include <fs_mgr.h>
32 #include <hardware_legacy/power.h>
33 #include <private/android_filesystem_config.h>
34
35 #include <dirent.h>
36 #include <fcntl.h>
37 #include <sys/mount.h>
38 #include <sys/stat.h>
39 #include <sys/types.h>
40 #include <sys/wait.h>
41
42 using android::base::Basename;
43 using android::base::ReadFileToString;
44 using android::base::Realpath;
45 using android::base::StringPrintf;
46 using android::base::Timer;
47 using android::base::WriteStringToFile;
48 using android::fs_mgr::Fstab;
49 using android::fs_mgr::ReadDefaultFstab;
50 using android::hardware::Return;
51 using android::hardware::Void;
52 using android::hardware::health::storage::V1_0::IStorage;
53 using android::hardware::health::storage::V1_0::IGarbageCollectCallback;
54 using android::hardware::health::storage::V1_0::Result;
55
56 namespace android {
57 namespace vold {
58
59 enum class PathTypes {
60 kMountPoint = 1,
61 kBlkDevice,
62 };
63
64 enum class IdleMaintStats {
65 kStopped = 1,
66 kRunning,
67 kAbort,
68 };
69
70 static const char* kWakeLock = "IdleMaint";
71 static const int DIRTY_SEGMENTS_THRESHOLD = 100;
72 /*
73 * Timing policy:
74 * 1. F2FS_GC = 7 mins
75 * 2. Trim = 1 min
76 * 3. Dev GC = 2 mins
77 */
78 static const int GC_TIMEOUT_SEC = 420;
79 static const int DEVGC_TIMEOUT_SEC = 120;
80
81 static IdleMaintStats idle_maint_stat(IdleMaintStats::kStopped);
82 static std::condition_variable cv_abort, cv_stop;
83 static std::mutex cv_m;
84
addFromVolumeManager(std::list<std::string> * paths,PathTypes path_type)85 static void addFromVolumeManager(std::list<std::string>* paths, PathTypes path_type) {
86 VolumeManager* vm = VolumeManager::Instance();
87 std::list<std::string> privateIds;
88 vm->listVolumes(VolumeBase::Type::kPrivate, privateIds);
89 for (const auto& id : privateIds) {
90 PrivateVolume* vol = static_cast<PrivateVolume*>(vm->findVolume(id).get());
91 if (vol != nullptr && vol->getState() == VolumeBase::State::kMounted) {
92 if (path_type == PathTypes::kMountPoint) {
93 paths->push_back(vol->getPath());
94 } else if (path_type == PathTypes::kBlkDevice) {
95 std::string gc_path;
96 const std::string& fs_type = vol->getFsType();
97 if (fs_type == "f2fs" && (Realpath(vol->getRawDmDevPath(), &gc_path) ||
98 Realpath(vol->getRawDevPath(), &gc_path))) {
99 paths->push_back(std::string("/sys/fs/") + fs_type + "/" + Basename(gc_path));
100 }
101 }
102 }
103 }
104 }
105
addFromFstab(std::list<std::string> * paths,PathTypes path_type)106 static void addFromFstab(std::list<std::string>* paths, PathTypes path_type) {
107 Fstab fstab;
108 ReadDefaultFstab(&fstab);
109
110 std::string previous_mount_point;
111 for (const auto& entry : fstab) {
112 // Skip raw partitions.
113 if (entry.fs_type == "emmc" || entry.fs_type == "mtd") {
114 continue;
115 }
116 // Skip read-only filesystems
117 if (entry.flags & MS_RDONLY) {
118 continue;
119 }
120 if (entry.fs_mgr_flags.vold_managed) {
121 continue; // Should we trim fat32 filesystems?
122 }
123 if (entry.fs_mgr_flags.no_trim) {
124 continue;
125 }
126
127 // Skip the multi-type partitions, which are required to be following each other.
128 // See fs_mgr.c's mount_with_alternatives().
129 if (entry.mount_point == previous_mount_point) {
130 continue;
131 }
132
133 if (path_type == PathTypes::kMountPoint) {
134 paths->push_back(entry.mount_point);
135 } else if (path_type == PathTypes::kBlkDevice) {
136 std::string gc_path;
137 if (entry.fs_type == "f2fs" &&
138 Realpath(android::vold::BlockDeviceForPath(entry.mount_point + "/"), &gc_path)) {
139 paths->push_back("/sys/fs/" + entry.fs_type + "/" + Basename(gc_path));
140 }
141 }
142
143 previous_mount_point = entry.mount_point;
144 }
145 }
146
Trim(const android::sp<android::os::IVoldTaskListener> & listener)147 void Trim(const android::sp<android::os::IVoldTaskListener>& listener) {
148 acquire_wake_lock(PARTIAL_WAKE_LOCK, kWakeLock);
149
150 // Collect both fstab and vold volumes
151 std::list<std::string> paths;
152 addFromFstab(&paths, PathTypes::kMountPoint);
153 addFromVolumeManager(&paths, PathTypes::kMountPoint);
154
155 for (const auto& path : paths) {
156 LOG(DEBUG) << "Starting trim of " << path;
157
158 android::os::PersistableBundle extras;
159 extras.putString(String16("path"), String16(path.c_str()));
160
161 int fd = open(path.c_str(), O_RDONLY | O_DIRECTORY | O_CLOEXEC | O_NOFOLLOW);
162 if (fd < 0) {
163 PLOG(WARNING) << "Failed to open " << path;
164 if (listener) {
165 listener->onStatus(-1, extras);
166 }
167 continue;
168 }
169
170 struct fstrim_range range;
171 memset(&range, 0, sizeof(range));
172 range.len = ULLONG_MAX;
173
174 nsecs_t start = systemTime(SYSTEM_TIME_BOOTTIME);
175 if (ioctl(fd, FITRIM, &range)) {
176 PLOG(WARNING) << "Trim failed on " << path;
177 if (listener) {
178 listener->onStatus(-1, extras);
179 }
180 } else {
181 nsecs_t time = systemTime(SYSTEM_TIME_BOOTTIME) - start;
182 LOG(INFO) << "Trimmed " << range.len << " bytes on " << path << " in "
183 << nanoseconds_to_milliseconds(time) << "ms";
184 extras.putLong(String16("bytes"), range.len);
185 extras.putLong(String16("time"), time);
186 if (listener) {
187 listener->onStatus(0, extras);
188 }
189 }
190 close(fd);
191 }
192
193 if (listener) {
194 android::os::PersistableBundle extras;
195 listener->onFinished(0, extras);
196 }
197
198 release_wake_lock(kWakeLock);
199 }
200
waitForGc(const std::list<std::string> & paths)201 static bool waitForGc(const std::list<std::string>& paths) {
202 std::unique_lock<std::mutex> lk(cv_m, std::defer_lock);
203 bool stop = false, aborted = false;
204 Timer timer;
205
206 while (!stop && !aborted) {
207 stop = true;
208 for (const auto& path : paths) {
209 std::string dirty_segments;
210 if (!ReadFileToString(path + "/dirty_segments", &dirty_segments)) {
211 PLOG(WARNING) << "Reading dirty_segments failed in " << path;
212 continue;
213 }
214 if (std::stoi(dirty_segments) > DIRTY_SEGMENTS_THRESHOLD) {
215 stop = false;
216 break;
217 }
218 }
219
220 if (stop) break;
221
222 if (timer.duration() >= std::chrono::seconds(GC_TIMEOUT_SEC)) {
223 LOG(WARNING) << "GC timeout";
224 break;
225 }
226
227 lk.lock();
228 aborted =
229 cv_abort.wait_for(lk, 10s, [] { return idle_maint_stat == IdleMaintStats::kAbort; });
230 lk.unlock();
231 }
232
233 return aborted;
234 }
235
startGc(const std::list<std::string> & paths)236 static int startGc(const std::list<std::string>& paths) {
237 for (const auto& path : paths) {
238 LOG(DEBUG) << "Start GC on " << path;
239 if (!WriteStringToFile("1", path + "/gc_urgent")) {
240 PLOG(WARNING) << "Start GC failed on " << path;
241 }
242 }
243 return android::OK;
244 }
245
stopGc(const std::list<std::string> & paths)246 static int stopGc(const std::list<std::string>& paths) {
247 for (const auto& path : paths) {
248 LOG(DEBUG) << "Stop GC on " << path;
249 if (!WriteStringToFile("0", path + "/gc_urgent")) {
250 PLOG(WARNING) << "Stop GC failed on " << path;
251 }
252 }
253 return android::OK;
254 }
255
runDevGcFstab(void)256 static void runDevGcFstab(void) {
257 Fstab fstab;
258 ReadDefaultFstab(&fstab);
259
260 std::string path;
261 for (const auto& entry : fstab) {
262 if (!entry.sysfs_path.empty()) {
263 path = entry.sysfs_path;
264 break;
265 }
266 }
267
268 if (path.empty()) {
269 return;
270 }
271
272 path = path + "/manual_gc";
273 Timer timer;
274
275 LOG(DEBUG) << "Start Dev GC on " << path;
276 while (1) {
277 std::string require;
278 if (!ReadFileToString(path, &require)) {
279 PLOG(WARNING) << "Reading manual_gc failed in " << path;
280 break;
281 }
282 require = android::base::Trim(require);
283 if (require == "" || require == "off" || require == "disabled") {
284 LOG(DEBUG) << "No more to do Dev GC";
285 break;
286 }
287
288 LOG(DEBUG) << "Trigger Dev GC on " << path;
289 if (!WriteStringToFile("1", path)) {
290 PLOG(WARNING) << "Start Dev GC failed on " << path;
291 break;
292 }
293
294 if (timer.duration() >= std::chrono::seconds(DEVGC_TIMEOUT_SEC)) {
295 LOG(WARNING) << "Dev GC timeout";
296 break;
297 }
298 sleep(2);
299 }
300 LOG(DEBUG) << "Stop Dev GC on " << path;
301 if (!WriteStringToFile("0", path)) {
302 PLOG(WARNING) << "Stop Dev GC failed on " << path;
303 }
304 return;
305 }
306
307 class GcCallback : public IGarbageCollectCallback {
308 public:
onFinish(Result result)309 Return<void> onFinish(Result result) override {
310 std::unique_lock<std::mutex> lock(mMutex);
311 mFinished = true;
312 mResult = result;
313 lock.unlock();
314 mCv.notify_all();
315 return Void();
316 }
wait(uint64_t seconds)317 void wait(uint64_t seconds) {
318 std::unique_lock<std::mutex> lock(mMutex);
319 mCv.wait_for(lock, std::chrono::seconds(seconds), [this] { return mFinished; });
320
321 if (!mFinished) {
322 LOG(WARNING) << "Dev GC on HAL timeout";
323 } else if (mResult != Result::SUCCESS) {
324 LOG(WARNING) << "Dev GC on HAL failed with " << toString(mResult);
325 } else {
326 LOG(INFO) << "Dev GC on HAL successful";
327 }
328 }
329
330 private:
331 std::mutex mMutex;
332 std::condition_variable mCv;
333 bool mFinished{false};
334 Result mResult{Result::UNKNOWN_ERROR};
335 };
336
runDevGcOnHal(sp<IStorage> service)337 static void runDevGcOnHal(sp<IStorage> service) {
338 LOG(DEBUG) << "Start Dev GC on HAL";
339 sp<GcCallback> cb = new GcCallback();
340 auto ret = service->garbageCollect(DEVGC_TIMEOUT_SEC, cb);
341 if (!ret.isOk()) {
342 LOG(WARNING) << "Cannot start Dev GC on HAL: " << ret.description();
343 return;
344 }
345 cb->wait(DEVGC_TIMEOUT_SEC);
346 }
347
runDevGc(void)348 static void runDevGc(void) {
349 auto service = IStorage::getService();
350 if (service != nullptr) {
351 runDevGcOnHal(service);
352 } else {
353 // fallback to legacy code path
354 runDevGcFstab();
355 }
356 }
357
RunIdleMaint(const android::sp<android::os::IVoldTaskListener> & listener)358 int RunIdleMaint(const android::sp<android::os::IVoldTaskListener>& listener) {
359 std::unique_lock<std::mutex> lk(cv_m);
360 if (idle_maint_stat != IdleMaintStats::kStopped) {
361 LOG(DEBUG) << "idle maintenance is already running";
362 if (listener) {
363 android::os::PersistableBundle extras;
364 listener->onFinished(0, extras);
365 }
366 return android::OK;
367 }
368 idle_maint_stat = IdleMaintStats::kRunning;
369 lk.unlock();
370
371 LOG(DEBUG) << "idle maintenance started";
372
373 acquire_wake_lock(PARTIAL_WAKE_LOCK, kWakeLock);
374
375 std::list<std::string> paths;
376 addFromFstab(&paths, PathTypes::kBlkDevice);
377 addFromVolumeManager(&paths, PathTypes::kBlkDevice);
378
379 startGc(paths);
380
381 bool gc_aborted = waitForGc(paths);
382
383 stopGc(paths);
384
385 lk.lock();
386 idle_maint_stat = IdleMaintStats::kStopped;
387 lk.unlock();
388
389 cv_stop.notify_one();
390
391 if (!gc_aborted) {
392 Trim(nullptr);
393 runDevGc();
394 }
395
396 if (listener) {
397 android::os::PersistableBundle extras;
398 listener->onFinished(0, extras);
399 }
400
401 LOG(DEBUG) << "idle maintenance completed";
402
403 release_wake_lock(kWakeLock);
404
405 return android::OK;
406 }
407
AbortIdleMaint(const android::sp<android::os::IVoldTaskListener> & listener)408 int AbortIdleMaint(const android::sp<android::os::IVoldTaskListener>& listener) {
409 acquire_wake_lock(PARTIAL_WAKE_LOCK, kWakeLock);
410
411 std::unique_lock<std::mutex> lk(cv_m);
412 if (idle_maint_stat != IdleMaintStats::kStopped) {
413 idle_maint_stat = IdleMaintStats::kAbort;
414 lk.unlock();
415 cv_abort.notify_one();
416 lk.lock();
417 LOG(DEBUG) << "aborting idle maintenance";
418 cv_stop.wait(lk, [] { return idle_maint_stat == IdleMaintStats::kStopped; });
419 }
420 lk.unlock();
421
422 if (listener) {
423 android::os::PersistableBundle extras;
424 listener->onFinished(0, extras);
425 }
426
427 release_wake_lock(kWakeLock);
428
429 LOG(DEBUG) << "idle maintenance stopped";
430
431 return android::OK;
432 }
433
434 } // namespace vold
435 } // namespace android
436