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 "TrimTask.h" 18 #include "Benchmark.h" 19 #include "Utils.h" 20 #include "VolumeManager.h" 21 #include "ResponseCode.h" 22 23 #include <android-base/stringprintf.h> 24 #include <android-base/logging.h> 25 #include <cutils/properties.h> 26 #include <fs_mgr.h> 27 #include <private/android_filesystem_config.h> 28 #include <hardware_legacy/power.h> 29 30 #include <dirent.h> 31 #include <sys/mount.h> 32 #include <sys/stat.h> 33 #include <sys/types.h> 34 #include <sys/wait.h> 35 #include <fcntl.h> 36 37 /* From a would-be kernel header */ 38 #define FIDTRIM _IOWR('f', 128, struct fstrim_range) /* Deep discard trim */ 39 40 #define BENCHMARK_ENABLED 1 41 42 using android::base::StringPrintf; 43 44 namespace android { 45 namespace vold { 46 47 static const char* kWakeLock = "TrimTask"; 48 49 TrimTask::TrimTask(int flags) : mFlags(flags) { 50 // Collect both fstab and vold volumes 51 addFromFstab(); 52 53 VolumeManager* vm = VolumeManager::Instance(); 54 std::list<std::string> privateIds; 55 vm->listVolumes(VolumeBase::Type::kPrivate, privateIds); 56 for (auto id : privateIds) { 57 auto vol = vm->findVolume(id); 58 if (vol != nullptr && vol->getState() == VolumeBase::State::kMounted) { 59 mPaths.push_back(vol->getPath()); 60 } 61 } 62 } 63 64 TrimTask::~TrimTask() { 65 } 66 67 void TrimTask::addFromFstab() { 68 struct fstab *fstab; 69 struct fstab_rec *prev_rec = NULL; 70 71 fstab = fs_mgr_read_fstab(android::vold::DefaultFstabPath().c_str()); 72 for (int i = 0; i < fstab->num_entries; i++) { 73 /* Skip raw partitions */ 74 if (!strcmp(fstab->recs[i].fs_type, "emmc") || 75 !strcmp(fstab->recs[i].fs_type, "mtd")) { 76 continue; 77 } 78 /* Skip read-only filesystems */ 79 if (fstab->recs[i].flags & MS_RDONLY) { 80 continue; 81 } 82 if (fs_mgr_is_voldmanaged(&fstab->recs[i])) { 83 continue; /* Should we trim fat32 filesystems? */ 84 } 85 if (fs_mgr_is_notrim(&fstab->recs[i])) { 86 continue; 87 } 88 89 /* Skip the multi-type partitions, which are required to be following each other. 90 * See fs_mgr.c's mount_with_alternatives(). 91 */ 92 if (prev_rec && !strcmp(prev_rec->mount_point, fstab->recs[i].mount_point)) { 93 continue; 94 } 95 96 mPaths.push_back(fstab->recs[i].mount_point); 97 prev_rec = &fstab->recs[i]; 98 } 99 fs_mgr_free_fstab(fstab); 100 } 101 102 void TrimTask::start() { 103 mThread = std::thread(&TrimTask::run, this); 104 } 105 106 static void notifyResult(const std::string& path, int64_t bytes, int64_t delta) { 107 std::string res(path 108 + " " + std::to_string(bytes) 109 + " " + std::to_string(delta)); 110 VolumeManager::Instance()->getBroadcaster()->sendBroadcast( 111 ResponseCode::TrimResult, res.c_str(), false); 112 } 113 114 void TrimTask::run() { 115 acquire_wake_lock(PARTIAL_WAKE_LOCK, kWakeLock); 116 117 for (auto path : mPaths) { 118 LOG(DEBUG) << "Starting trim of " << path; 119 120 int fd = open(path.c_str(), O_RDONLY | O_DIRECTORY | O_CLOEXEC | O_NOFOLLOW); 121 if (fd < 0) { 122 PLOG(WARNING) << "Failed to open " << path; 123 continue; 124 } 125 126 struct fstrim_range range; 127 memset(&range, 0, sizeof(range)); 128 range.len = ULLONG_MAX; 129 130 nsecs_t start = systemTime(SYSTEM_TIME_BOOTTIME); 131 if (ioctl(fd, (mFlags & Flags::kDeepTrim) ? FIDTRIM : FITRIM, &range)) { 132 PLOG(WARNING) << "Trim failed on " << path; 133 notifyResult(path, -1, -1); 134 } else { 135 nsecs_t delta = systemTime(SYSTEM_TIME_BOOTTIME) - start; 136 LOG(INFO) << "Trimmed " << range.len << " bytes on " << path 137 << " in " << nanoseconds_to_milliseconds(delta) << "ms"; 138 notifyResult(path, range.len, delta); 139 } 140 close(fd); 141 142 if (mFlags & Flags::kBenchmarkAfter) { 143 #if BENCHMARK_ENABLED 144 BenchmarkPrivate(path); 145 #else 146 LOG(DEBUG) << "Benchmark disabled"; 147 #endif 148 } 149 } 150 151 release_wake_lock(kWakeLock); 152 } 153 154 } // namespace vold 155 } // namespace android 156