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 "MoveTask.h"
18 #include "Utils.h"
19 #include "VolumeManager.h"
20 #include "ResponseCode.h"
21
22 #include <android-base/stringprintf.h>
23 #include <android-base/logging.h>
24 #include <private/android_filesystem_config.h>
25 #include <hardware_legacy/power.h>
26
27 #include <dirent.h>
28 #include <sys/wait.h>
29
30 #define CONSTRAIN(amount, low, high) ((amount) < (low) ? (low) : ((amount) > (high) ? (high) : (amount)))
31
32 #define EXEC_BLOCKING 0
33
34 using android::base::StringPrintf;
35
36 namespace android {
37 namespace vold {
38
39 // TODO: keep in sync with PackageManager
40 static const int kMoveSucceeded = -100;
41 static const int kMoveFailedInternalError = -6;
42
43 static const char* kCpPath = "/system/bin/cp";
44 static const char* kRmPath = "/system/bin/rm";
45
46 static const char* kWakeLock = "MoveTask";
47
MoveTask(const std::shared_ptr<VolumeBase> & from,const std::shared_ptr<VolumeBase> & to)48 MoveTask::MoveTask(const std::shared_ptr<VolumeBase>& from,
49 const std::shared_ptr<VolumeBase>& to) :
50 mFrom(from), mTo(to) {
51 }
52
~MoveTask()53 MoveTask::~MoveTask() {
54 }
55
start()56 void MoveTask::start() {
57 mThread = std::thread(&MoveTask::run, this);
58 }
59
notifyProgress(int progress)60 static void notifyProgress(int progress) {
61 VolumeManager::Instance()->getBroadcaster()->sendBroadcast(ResponseCode::MoveStatus,
62 StringPrintf("%d", progress).c_str(), false);
63 }
64
pushBackContents(const std::string & path,std::vector<std::string> & cmd)65 static status_t pushBackContents(const std::string& path, std::vector<std::string>& cmd) {
66 DIR* dir = opendir(path.c_str());
67 if (dir == NULL) {
68 return -1;
69 }
70 bool found = false;
71 struct dirent* ent;
72 while ((ent = readdir(dir)) != NULL) {
73 if ((!strcmp(ent->d_name, ".")) || (!strcmp(ent->d_name, ".."))) {
74 continue;
75 }
76 cmd.push_back(StringPrintf("%s/%s", path.c_str(), ent->d_name));
77 found = true;
78 }
79 closedir(dir);
80 return found ? OK : -1;
81 }
82
execRm(const std::string & path,int startProgress,int stepProgress)83 static status_t execRm(const std::string& path, int startProgress, int stepProgress) {
84 notifyProgress(startProgress);
85
86 uint64_t expectedBytes = GetTreeBytes(path);
87 uint64_t startFreeBytes = GetFreeBytes(path);
88
89 std::vector<std::string> cmd;
90 cmd.push_back(kRmPath);
91 cmd.push_back("-f"); /* force: remove without confirmation, no error if it doesn't exist */
92 cmd.push_back("-R"); /* recursive: remove directory contents */
93 if (pushBackContents(path, cmd) != OK) {
94 LOG(WARNING) << "No contents in " << path;
95 return OK;
96 }
97
98 #if EXEC_BLOCKING
99 return ForkExecvp(cmd);
100 #else
101 pid_t pid = ForkExecvpAsync(cmd);
102 if (pid == -1) return -1;
103
104 int status;
105 while (true) {
106 if (waitpid(pid, &status, WNOHANG) == pid) {
107 if (WIFEXITED(status)) {
108 LOG(DEBUG) << "Finished rm with status " << WEXITSTATUS(status);
109 return (WEXITSTATUS(status) == 0) ? OK : -1;
110 } else {
111 break;
112 }
113 }
114
115 sleep(1);
116 uint64_t deltaFreeBytes = GetFreeBytes(path) - startFreeBytes;
117 notifyProgress(startProgress + CONSTRAIN((int)
118 ((deltaFreeBytes * stepProgress) / expectedBytes), 0, stepProgress));
119 }
120 return -1;
121 #endif
122 }
123
execCp(const std::string & fromPath,const std::string & toPath,int startProgress,int stepProgress)124 static status_t execCp(const std::string& fromPath, const std::string& toPath,
125 int startProgress, int stepProgress) {
126 notifyProgress(startProgress);
127
128 uint64_t expectedBytes = GetTreeBytes(fromPath);
129 uint64_t startFreeBytes = GetFreeBytes(toPath);
130
131 if (expectedBytes > startFreeBytes) {
132 LOG(ERROR) << "Data size " << expectedBytes << " is too large to fit in free space "
133 << startFreeBytes;
134 return -1;
135 }
136
137 std::vector<std::string> cmd;
138 cmd.push_back(kCpPath);
139 cmd.push_back("-p"); /* preserve timestamps, ownership, and permissions */
140 cmd.push_back("-R"); /* recurse into subdirectories (DEST must be a directory) */
141 cmd.push_back("-P"); /* Do not follow symlinks [default] */
142 cmd.push_back("-d"); /* don't dereference symlinks */
143 if (pushBackContents(fromPath, cmd) != OK) {
144 LOG(WARNING) << "No contents in " << fromPath;
145 return OK;
146 }
147 cmd.push_back(toPath.c_str());
148
149 #if EXEC_BLOCKING
150 return ForkExecvp(cmd);
151 #else
152 pid_t pid = ForkExecvpAsync(cmd);
153 if (pid == -1) return -1;
154
155 int status;
156 while (true) {
157 if (waitpid(pid, &status, WNOHANG) == pid) {
158 if (WIFEXITED(status)) {
159 LOG(DEBUG) << "Finished cp with status " << WEXITSTATUS(status);
160 return (WEXITSTATUS(status) == 0) ? OK : -1;
161 } else {
162 break;
163 }
164 }
165
166 sleep(1);
167 uint64_t deltaFreeBytes = startFreeBytes - GetFreeBytes(toPath);
168 notifyProgress(startProgress + CONSTRAIN((int)
169 ((deltaFreeBytes * stepProgress) / expectedBytes), 0, stepProgress));
170 }
171 return -1;
172 #endif
173 }
174
bringOffline(const std::shared_ptr<VolumeBase> & vol)175 static void bringOffline(const std::shared_ptr<VolumeBase>& vol) {
176 vol->destroy();
177 vol->setSilent(true);
178 vol->create();
179 vol->setMountFlags(0);
180 vol->mount();
181 }
182
bringOnline(const std::shared_ptr<VolumeBase> & vol)183 static void bringOnline(const std::shared_ptr<VolumeBase>& vol) {
184 vol->destroy();
185 vol->setSilent(false);
186 vol->create();
187 }
188
run()189 void MoveTask::run() {
190 acquire_wake_lock(PARTIAL_WAKE_LOCK, kWakeLock);
191
192 std::string fromPath;
193 std::string toPath;
194
195 // TODO: add support for public volumes
196 if (mFrom->getType() != VolumeBase::Type::kEmulated) goto fail;
197 if (mTo->getType() != VolumeBase::Type::kEmulated) goto fail;
198
199 // Step 1: tear down volumes and mount silently without making
200 // visible to userspace apps
201 {
202 std::lock_guard<std::mutex> lock(VolumeManager::Instance()->getLock());
203 bringOffline(mFrom);
204 bringOffline(mTo);
205 }
206
207 fromPath = mFrom->getInternalPath();
208 toPath = mTo->getInternalPath();
209
210 // Step 2: clean up any stale data
211 if (execRm(toPath, 10, 10) != OK) {
212 goto fail;
213 }
214
215 // Step 3: perform actual copy
216 if (execCp(fromPath, toPath, 20, 60) != OK) {
217 goto copy_fail;
218 }
219
220 // NOTE: MountService watches for this magic value to know
221 // that move was successful
222 notifyProgress(82);
223 {
224 std::lock_guard<std::mutex> lock(VolumeManager::Instance()->getLock());
225 bringOnline(mFrom);
226 bringOnline(mTo);
227 }
228
229 // Step 4: clean up old data
230 if (execRm(fromPath, 85, 15) != OK) {
231 goto fail;
232 }
233
234 notifyProgress(kMoveSucceeded);
235 release_wake_lock(kWakeLock);
236 return;
237
238 copy_fail:
239 // if we failed to copy the data we should not leave it laying around
240 // in target location. Do not check return value, we can not do any
241 // useful anyway.
242 execRm(toPath, 80, 1);
243 fail:
244 {
245 std::lock_guard<std::mutex> lock(VolumeManager::Instance()->getLock());
246 bringOnline(mFrom);
247 bringOnline(mTo);
248 }
249 notifyProgress(kMoveFailedInternalError);
250 release_wake_lock(kWakeLock);
251 return;
252 }
253
254 } // namespace vold
255 } // namespace android
256