IdleMaint.cpp

   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::IGarbageCollectCallback;
  53 using android::hardware::health::storage::V1_0::IStorage;
  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
  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
 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
 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
 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
 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 + "/discard_granularity")) {
 240             PLOG(WARNING) << "Set discard gralunarity failed on" << path;
 241         }
 242         if (!WriteStringToFile("1", path + "/gc_urgent")) {
 243             PLOG(WARNING) << "Start GC failed on " << path;
 244         }
 245     }
 246     return android::OK;
 247 }
 248
 249 static int stopGc(const std::list<std::string>& paths) {
 250     for (const auto& path : paths) {
 251         LOG(DEBUG) << "Stop GC on " << path;
 252         if (!WriteStringToFile("0", path + "/gc_urgent")) {
 253             PLOG(WARNING) << "Stop GC failed on " << path;
 254         }
 255         if (!WriteStringToFile("16", path + "/discard_granularity")) {
 256             PLOG(WARNING) << "Set discard gralunarity failed on" << path;
 257         }
 258     }
 259     return android::OK;
 260 }
 261
 262 static void runDevGcFstab(void) {
 263     Fstab fstab;
 264     ReadDefaultFstab(&fstab);
 265
 266     std::string path;
 267     for (const auto& entry : fstab) {
 268         if (!entry.sysfs_path.empty()) {
 269             path = entry.sysfs_path;
 270             break;
 271         }
 272     }
 273
 274     if (path.empty()) {
 275         return;
 276     }
 277
 278     path = path + "/manual_gc";
 279     Timer timer;
 280
 281     LOG(DEBUG) << "Start Dev GC on " << path;
 282     while (1) {
 283         std::string require;
 284         if (!ReadFileToString(path, &require)) {
 285             PLOG(WARNING) << "Reading manual_gc failed in " << path;
 286             break;
 287         }
 288         require = android::base::Trim(require);
 289         if (require == "" || require == "off" || require == "disabled") {
 290             LOG(DEBUG) << "No more to do Dev GC";
 291             break;
 292         }
 293
 294         LOG(DEBUG) << "Trigger Dev GC on " << path;
 295         if (!WriteStringToFile("1", path)) {
 296             PLOG(WARNING) << "Start Dev GC failed on " << path;
 297             break;
 298         }
 299
 300         if (timer.duration() >= std::chrono::seconds(DEVGC_TIMEOUT_SEC)) {
 301             LOG(WARNING) << "Dev GC timeout";
 302             break;
 303         }
 304         sleep(2);
 305     }
 306     LOG(DEBUG) << "Stop Dev GC on " << path;
 307     if (!WriteStringToFile("0", path)) {
 308         PLOG(WARNING) << "Stop Dev GC failed on " << path;
 309     }
 310     return;
 311 }
 312
 313 class GcCallback : public IGarbageCollectCallback {
 314   public:
 315     Return<void> onFinish(Result result) override {
 316         std::unique_lock<std::mutex> lock(mMutex);
 317         mFinished = true;
 318         mResult = result;
 319         lock.unlock();
 320         mCv.notify_all();
 321         return Void();
 322     }
 323     void wait(uint64_t seconds) {
 324         std::unique_lock<std::mutex> lock(mMutex);
 325         mCv.wait_for(lock, std::chrono::seconds(seconds), [this] { return mFinished; });
 326
 327         if (!mFinished) {
 328             LOG(WARNING) << "Dev GC on HAL timeout";
 329         } else if (mResult != Result::SUCCESS) {
 330             LOG(WARNING) << "Dev GC on HAL failed with " << toString(mResult);
 331         } else {
 332             LOG(INFO) << "Dev GC on HAL successful";
 333         }
 334     }
 335
 336   private:
 337     std::mutex mMutex;
 338     std::condition_variable mCv;
 339     bool mFinished{false};
 340     Result mResult{Result::UNKNOWN_ERROR};
 341 };
 342
 343 static void runDevGcOnHal(sp<IStorage> service) {
 344     LOG(DEBUG) << "Start Dev GC on HAL";
 345     sp<GcCallback> cb = new GcCallback();
 346     auto ret = service->garbageCollect(DEVGC_TIMEOUT_SEC, cb);
 347     if (!ret.isOk()) {
 348         LOG(WARNING) << "Cannot start Dev GC on HAL: " << ret.description();
 349         return;
 350     }
 351     cb->wait(DEVGC_TIMEOUT_SEC);
 352 }
 353
 354 static void runDevGc(void) {
 355     auto service = IStorage::getService();
 356     if (service != nullptr) {
 357         runDevGcOnHal(service);
 358     } else {
 359         // fallback to legacy code path
 360         runDevGcFstab();
 361     }
 362 }
 363
 364 int RunIdleMaint(const android::sp<android::os::IVoldTaskListener>& listener) {
 365     std::unique_lock<std::mutex> lk(cv_m);
 366     if (idle_maint_stat != IdleMaintStats::kStopped) {
 367         LOG(DEBUG) << "idle maintenance is already running";
 368         if (listener) {
 369             android::os::PersistableBundle extras;
 370             listener->onFinished(0, extras);
 371         }
 372         return android::OK;
 373     }
 374     idle_maint_stat = IdleMaintStats::kRunning;
 375     lk.unlock();
 376
 377     LOG(DEBUG) << "idle maintenance started";
 378
 379     acquire_wake_lock(PARTIAL_WAKE_LOCK, kWakeLock);
 380
 381     std::list<std::string> paths;
 382     addFromFstab(&paths, PathTypes::kBlkDevice);
 383     addFromVolumeManager(&paths, PathTypes::kBlkDevice);
 384
 385     startGc(paths);
 386
 387     bool gc_aborted = waitForGc(paths);
 388
 389     stopGc(paths);
 390
 391     lk.lock();
 392     idle_maint_stat = IdleMaintStats::kStopped;
 393     lk.unlock();
 394
 395     cv_stop.notify_one();
 396
 397     if (!gc_aborted) {
 398         Trim(nullptr);
 399         runDevGc();
 400     }
 401
 402     if (listener) {
 403         android::os::PersistableBundle extras;
 404         listener->onFinished(0, extras);
 405     }
 406
 407     LOG(DEBUG) << "idle maintenance completed";
 408
 409     release_wake_lock(kWakeLock);
 410
 411     return android::OK;
 412 }
 413
 414 int AbortIdleMaint(const android::sp<android::os::IVoldTaskListener>& listener) {
 415     acquire_wake_lock(PARTIAL_WAKE_LOCK, kWakeLock);
 416
 417     std::unique_lock<std::mutex> lk(cv_m);
 418     if (idle_maint_stat != IdleMaintStats::kStopped) {
 419         idle_maint_stat = IdleMaintStats::kAbort;
 420         lk.unlock();
 421         cv_abort.notify_one();
 422         lk.lock();
 423         LOG(DEBUG) << "aborting idle maintenance";
 424         cv_stop.wait(lk, [] { return idle_maint_stat == IdleMaintStats::kStopped; });
 425     }
 426     lk.unlock();
 427
 428     if (listener) {
 429         android::os::PersistableBundle extras;
 430         listener->onFinished(0, extras);
 431     }
 432
 433     release_wake_lock(kWakeLock);
 434
 435     LOG(DEBUG) << "idle maintenance stopped";
 436
 437     return android::OK;
 438 }
 439
 440 }  // namespace vold
 441 }  // namespace android