blob: 5cba7b67cb36bdd0540498fcd598d859cd36b0fa [file] [log] [blame]
Doug Zongker9270a202012-01-09 15:16:13 -08001/*
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
xunchang24788852019-03-22 16:08:52 -070017#include "install/adb_install.h"
Tao Bao0150d012017-05-01 11:31:28 -070018
Doug Zongker9270a202012-01-09 15:16:13 -080019#include <errno.h>
Tao Bao0150d012017-05-01 11:31:28 -070020#include <fcntl.h>
21#include <signal.h>
Doug Zongker9270a202012-01-09 15:16:13 -080022#include <stdlib.h>
23#include <string.h>
xunchang34690ce2019-04-05 16:16:07 -070024#include <sys/epoll.h>
25#include <sys/socket.h>
Tao Bao0150d012017-05-01 11:31:28 -070026#include <sys/stat.h>
Doug Zongker9270a202012-01-09 15:16:13 -080027#include <sys/types.h>
28#include <sys/wait.h>
Tao Bao0150d012017-05-01 11:31:28 -070029#include <unistd.h>
Doug Zongker9270a202012-01-09 15:16:13 -080030
xunchang34690ce2019-04-05 16:16:07 -070031#include <atomic>
32#include <functional>
33#include <map>
Tao Bao10f441a2019-04-19 15:22:15 -070034#include <utility>
Tao Baoc6dc3252019-04-16 14:22:25 -070035#include <vector>
xunchang34690ce2019-04-05 16:16:07 -070036
37#include <android-base/file.h>
Tao Bao0167d4c2017-05-11 14:44:15 -070038#include <android-base/logging.h>
xunchang34690ce2019-04-05 16:16:07 -070039#include <android-base/memory.h>
Elliott Hughescb220402016-09-23 15:30:55 -070040#include <android-base/properties.h>
xunchang34690ce2019-04-05 16:16:07 -070041#include <android-base/strings.h>
42#include <android-base/unique_fd.h>
Elliott Hughescb220402016-09-23 15:30:55 -070043
Tao Bao0150d012017-05-01 11:31:28 -070044#include "fuse_sideload.h"
xunchang24788852019-03-22 16:08:52 -070045#include "install/install.h"
xunchangfedeef62019-04-22 12:18:14 -070046#include "install/wipe_data.h"
Tao Bao3305d482019-09-26 00:02:29 -070047#include "minadbd/types.h"
Tao Baoc6dc3252019-04-16 14:22:25 -070048#include "otautil/sysutil.h"
Tao Bao10f441a2019-04-19 15:22:15 -070049#include "recovery_ui/device.h"
Tianjie Xu8f397302018-08-20 13:40:47 -070050#include "recovery_ui/ui.h"
Tao Bao0150d012017-05-01 11:31:28 -070051
Tao Bao10f441a2019-04-19 15:22:15 -070052// A CommandFunction returns a pair of (result, should_continue), which indicates the command
53// execution result and whether it should proceed to the next iteration. The execution result will
54// always be sent to the minadbd side.
55using CommandFunction = std::function<std::pair<bool, bool>()>;
xunchang34690ce2019-04-05 16:16:07 -070056
xunchang24788852019-03-22 16:08:52 -070057static bool SetUsbConfig(const std::string& state) {
58 android::base::SetProperty("sys.usb.config", state);
59 return android::base::WaitForProperty("sys.usb.state", state);
60}
61
Tao Bao10f441a2019-04-19 15:22:15 -070062// Parses the minadbd command in |message|; returns MinadbdCommand::kError upon errors.
63static MinadbdCommand ParseMinadbdCommand(const std::string& message) {
xunchang34690ce2019-04-05 16:16:07 -070064 if (!android::base::StartsWith(message, kMinadbdCommandPrefix)) {
65 LOG(ERROR) << "Failed to parse command in message " << message;
Tao Bao10f441a2019-04-19 15:22:15 -070066 return MinadbdCommand::kError;
xunchang34690ce2019-04-05 16:16:07 -070067 }
68
69 auto cmd_code_string = message.substr(strlen(kMinadbdCommandPrefix));
70 auto cmd_code = android::base::get_unaligned<uint32_t>(cmd_code_string.c_str());
Tao Bao10f441a2019-04-19 15:22:15 -070071 if (cmd_code >= static_cast<uint32_t>(MinadbdCommand::kError)) {
xunchang34690ce2019-04-05 16:16:07 -070072 LOG(ERROR) << "Unsupported command code: " << cmd_code;
Tao Bao10f441a2019-04-19 15:22:15 -070073 return MinadbdCommand::kError;
xunchang34690ce2019-04-05 16:16:07 -070074 }
75
Tao Bao10f441a2019-04-19 15:22:15 -070076 return static_cast<MinadbdCommand>(cmd_code);
xunchang34690ce2019-04-05 16:16:07 -070077}
78
79static bool WriteStatusToFd(MinadbdCommandStatus status, int fd) {
80 char message[kMinadbdMessageSize];
81 memcpy(message, kMinadbdStatusPrefix, strlen(kMinadbdStatusPrefix));
82 android::base::put_unaligned(message + strlen(kMinadbdStatusPrefix), status);
83
84 if (!android::base::WriteFully(fd, message, kMinadbdMessageSize)) {
85 PLOG(ERROR) << "Failed to write message " << message;
86 return false;
87 }
88 return true;
89}
90
Tao Bao10f441a2019-04-19 15:22:15 -070091// Installs the package from FUSE. Returns the installation result and whether it should continue
92// waiting for new commands.
Kelvin Zhanga4208b52022-02-14 18:38:06 -080093static auto AdbInstallPackageHandler(Device* device, InstallResult* result) {
xunchang34690ce2019-04-05 16:16:07 -070094 // How long (in seconds) we wait for the package path to be ready. It doesn't need to be too long
95 // because the minadbd service has already issued an install command. FUSE_SIDELOAD_HOST_PATHNAME
96 // will start to exist once the host connects and starts serving a package. Poll for its
97 // appearance. (Note that inotify doesn't work with FUSE.)
Kelvin Zhanga4208b52022-02-14 18:38:06 -080098 auto ui = device->GetUI();
xunchang34690ce2019-04-05 16:16:07 -070099 constexpr int ADB_INSTALL_TIMEOUT = 15;
Tao Bao10f441a2019-04-19 15:22:15 -0700100 bool should_continue = true;
xunchang34690ce2019-04-05 16:16:07 -0700101 *result = INSTALL_ERROR;
102 for (int i = 0; i < ADB_INSTALL_TIMEOUT; ++i) {
103 struct stat st;
104 if (stat(FUSE_SIDELOAD_HOST_PATHNAME, &st) != 0) {
105 if (errno == ENOENT && i < ADB_INSTALL_TIMEOUT - 1) {
106 sleep(1);
107 continue;
108 } else {
Tao Bao10f441a2019-04-19 15:22:15 -0700109 should_continue = false;
xunchang34690ce2019-04-05 16:16:07 -0700110 ui->Print("\nTimed out waiting for fuse to be ready.\n\n");
111 break;
112 }
113 }
Tianjie Xu980f92e2019-06-11 15:43:43 -0700114
115 auto package =
116 Package::CreateFilePackage(FUSE_SIDELOAD_HOST_PATHNAME,
117 std::bind(&RecoveryUI::SetProgress, ui, std::placeholders::_1));
Kelvin Zhanga4208b52022-02-14 18:38:06 -0800118 *result = InstallPackage(package.get(), FUSE_SIDELOAD_HOST_PATHNAME, false, 0, device);
xunchang34690ce2019-04-05 16:16:07 -0700119 break;
120 }
121
122 // Calling stat() on this magic filename signals the FUSE to exit.
123 struct stat st;
124 stat(FUSE_SIDELOAD_HOST_EXIT_PATHNAME, &st);
Tao Bao10f441a2019-04-19 15:22:15 -0700125 return std::make_pair(*result == INSTALL_SUCCESS, should_continue);
xunchang34690ce2019-04-05 16:16:07 -0700126}
127
Tao Baoadc99ef2019-04-29 23:48:02 -0700128static auto AdbRebootHandler(MinadbdCommand command, InstallResult* result,
Tao Bao10f441a2019-04-19 15:22:15 -0700129 Device::BuiltinAction* reboot_action) {
Tao Baod9cb0142019-04-23 11:46:25 -0700130 // Use Device::REBOOT_{FASTBOOT,RECOVERY,RESCUE}, instead of the ones with ENTER_. This allows
131 // rebooting back into fastboot/recovery/rescue mode through bootloader, which may use a newly
132 // installed bootloader/recovery image.
Tao Bao10f441a2019-04-19 15:22:15 -0700133 switch (command) {
134 case MinadbdCommand::kRebootBootloader:
135 *reboot_action = Device::REBOOT_BOOTLOADER;
136 break;
137 case MinadbdCommand::kRebootFastboot:
Tao Baod9cb0142019-04-23 11:46:25 -0700138 *reboot_action = Device::REBOOT_FASTBOOT;
Tao Bao10f441a2019-04-19 15:22:15 -0700139 break;
140 case MinadbdCommand::kRebootRecovery:
Tao Baod9cb0142019-04-23 11:46:25 -0700141 *reboot_action = Device::REBOOT_RECOVERY;
Tao Bao10f441a2019-04-19 15:22:15 -0700142 break;
143 case MinadbdCommand::kRebootRescue:
Tao Bao10f441a2019-04-19 15:22:15 -0700144 *reboot_action = Device::REBOOT_RESCUE;
145 break;
146 case MinadbdCommand::kRebootAndroid:
147 default:
148 *reboot_action = Device::REBOOT;
149 break;
150 }
151 *result = INSTALL_REBOOT;
152 return std::make_pair(true, false);
153}
154
155// Parses and executes the command from minadbd. Returns whether the caller should keep waiting for
156// next command.
157static bool HandleMessageFromMinadbd(int socket_fd,
158 const std::map<MinadbdCommand, CommandFunction>& command_map) {
xunchang34690ce2019-04-05 16:16:07 -0700159 char buffer[kMinadbdMessageSize];
160 if (!android::base::ReadFully(socket_fd, buffer, kMinadbdMessageSize)) {
161 PLOG(ERROR) << "Failed to read message from minadbd";
162 return false;
163 }
164
165 std::string message(buffer, buffer + kMinadbdMessageSize);
Tao Bao10f441a2019-04-19 15:22:15 -0700166 auto command_type = ParseMinadbdCommand(message);
167 if (command_type == MinadbdCommand::kError) {
xunchang34690ce2019-04-05 16:16:07 -0700168 return false;
169 }
170 if (command_map.find(command_type) == command_map.end()) {
171 LOG(ERROR) << "Unsupported command: "
172 << android::base::get_unaligned<unsigned int>(
173 message.substr(strlen(kMinadbdCommandPrefix)).c_str());
174 return false;
175 }
176
177 // We have received a valid command, execute the corresponding function.
178 const auto& command_func = command_map.at(command_type);
Tao Bao10f441a2019-04-19 15:22:15 -0700179 const auto [result, should_continue] = command_func();
180 LOG(INFO) << "Command " << static_cast<uint32_t>(command_type) << " finished with " << result;
181 if (!WriteStatusToFd(result ? MinadbdCommandStatus::kSuccess : MinadbdCommandStatus::kFailure,
182 socket_fd)) {
183 return false;
xunchang34690ce2019-04-05 16:16:07 -0700184 }
Tao Bao10f441a2019-04-19 15:22:15 -0700185 return should_continue;
xunchang34690ce2019-04-05 16:16:07 -0700186}
187
188// TODO(xunchang) add a wrapper function and kill the minadbd service there.
189static void ListenAndExecuteMinadbdCommands(
Tao Baod9cb0142019-04-23 11:46:25 -0700190 RecoveryUI* ui, pid_t minadbd_pid, android::base::unique_fd&& socket_fd,
Tao Bao10f441a2019-04-19 15:22:15 -0700191 const std::map<MinadbdCommand, CommandFunction>& command_map) {
xunchang34690ce2019-04-05 16:16:07 -0700192 android::base::unique_fd epoll_fd(epoll_create1(O_CLOEXEC));
193 if (epoll_fd == -1) {
194 PLOG(ERROR) << "Failed to create epoll";
195 kill(minadbd_pid, SIGKILL);
196 return;
197 }
198
199 constexpr int EPOLL_MAX_EVENTS = 10;
200 struct epoll_event ev = {};
201 ev.events = EPOLLIN | EPOLLHUP;
202 ev.data.fd = socket_fd.get();
203 struct epoll_event events[EPOLL_MAX_EVENTS];
204 if (epoll_ctl(epoll_fd.get(), EPOLL_CTL_ADD, socket_fd.get(), &ev) == -1) {
205 PLOG(ERROR) << "Failed to add socket fd to epoll";
206 kill(minadbd_pid, SIGKILL);
207 return;
208 }
209
210 // Set the timeout to be 300s when waiting for minadbd commands.
211 constexpr int TIMEOUT_MILLIS = 300 * 1000;
212 while (true) {
Tao Baod9cb0142019-04-23 11:46:25 -0700213 // Reset the progress bar and the background image before each command.
214 ui->SetProgressType(RecoveryUI::EMPTY);
215 ui->SetBackground(RecoveryUI::NO_COMMAND);
216
xunchang34690ce2019-04-05 16:16:07 -0700217 // Poll for the status change of the socket_fd, and handle the message if the fd is ready to
218 // read.
219 int event_count =
220 TEMP_FAILURE_RETRY(epoll_wait(epoll_fd.get(), events, EPOLL_MAX_EVENTS, TIMEOUT_MILLIS));
221 if (event_count == -1) {
222 PLOG(ERROR) << "Failed to wait for epoll events";
223 kill(minadbd_pid, SIGKILL);
224 return;
225 }
226 if (event_count == 0) {
227 LOG(ERROR) << "Timeout waiting for messages from minadbd";
228 kill(minadbd_pid, SIGKILL);
229 return;
230 }
231
232 for (int n = 0; n < event_count; n++) {
233 if (events[n].events & EPOLLHUP) {
234 LOG(INFO) << "Socket has been closed";
235 kill(minadbd_pid, SIGKILL);
236 return;
237 }
238 if (!HandleMessageFromMinadbd(socket_fd.get(), command_map)) {
239 kill(minadbd_pid, SIGKILL);
240 return;
241 }
242 }
243 }
244}
245
246// Recovery starts minadbd service as a child process, and spawns another thread to listen for the
247// message from minadbd through a socket pair. Here is an example to execute one command from adb
248// host.
249// a. recovery b. listener thread c. minadbd service
250//
251// a1. create socket pair
252// a2. fork minadbd service
253// c3. wait for the adb commands
254// from host
255// c4. after receiving host commands:
256// 1) set up pre-condition (i.e.
257// start fuse for adb sideload)
258// 2) issue command through
259// socket.
260// 3) wait for result
261// a5. start listener thread
262// b6. listen for message from
263// minadbd in a loop.
264// b7. After receiving a minadbd
265// command from socket
266// 1) execute the command function
267// 2) send the result back to
268// minadbd
269// ......
270// c8. exit upon receiving the
271// result
272// a9. wait for listener thread
273// to exit.
274//
275// a10. wait for minadbd to
276// exit
277// b11. exit the listening loop
278//
279static void CreateMinadbdServiceAndExecuteCommands(
Tao Baod9cb0142019-04-23 11:46:25 -0700280 RecoveryUI* ui, const std::map<MinadbdCommand, CommandFunction>& command_map,
281 bool rescue_mode) {
xunchang34690ce2019-04-05 16:16:07 -0700282 signal(SIGPIPE, SIG_IGN);
283
284 android::base::unique_fd recovery_socket;
285 android::base::unique_fd minadbd_socket;
286 if (!android::base::Socketpair(AF_UNIX, SOCK_STREAM, 0, &recovery_socket, &minadbd_socket)) {
287 PLOG(ERROR) << "Failed to create socket";
288 return;
289 }
290
291 pid_t child = fork();
292 if (child == -1) {
293 PLOG(ERROR) << "Failed to fork child process";
294 return;
295 }
296 if (child == 0) {
297 recovery_socket.reset();
Tao Baoc6dc3252019-04-16 14:22:25 -0700298 std::vector<std::string> minadbd_commands = {
299 "/system/bin/minadbd",
300 "--socket_fd",
301 std::to_string(minadbd_socket.release()),
302 };
303 if (rescue_mode) {
304 minadbd_commands.push_back("--rescue");
305 }
306 auto exec_args = StringVectorToNullTerminatedArray(minadbd_commands);
307 execv(exec_args[0], exec_args.data());
xunchang34690ce2019-04-05 16:16:07 -0700308 _exit(EXIT_FAILURE);
309 }
310
311 minadbd_socket.reset();
312
313 // We need to call SetUsbConfig() after forking minadbd service. Because the function waits for
314 // the usb state to be updated, which depends on sys.usb.ffs.ready=1 set in the adb daemon.
315 if (!SetUsbConfig("sideload")) {
316 LOG(ERROR) << "Failed to set usb config to sideload";
317 return;
318 }
319
Tao Baod9cb0142019-04-23 11:46:25 -0700320 std::thread listener_thread(ListenAndExecuteMinadbdCommands, ui, child,
321 std::move(recovery_socket), std::ref(command_map));
xunchang34690ce2019-04-05 16:16:07 -0700322 if (listener_thread.joinable()) {
323 listener_thread.join();
324 }
325
326 int status;
327 waitpid(child, &status, 0);
328 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
329 if (WEXITSTATUS(status) == MinadbdErrorCode::kMinadbdAdbVersionError) {
330 LOG(ERROR) << "\nYou need adb 1.0.32 or newer to sideload\nto this device.\n";
331 } else if (!WIFSIGNALED(status)) {
332 LOG(ERROR) << "\n(adbd status " << WEXITSTATUS(status) << ")";
333 }
334 }
335
336 signal(SIGPIPE, SIG_DFL);
337}
338
Tao Baoadc99ef2019-04-29 23:48:02 -0700339InstallResult ApplyFromAdb(Device* device, bool rescue_mode, Device::BuiltinAction* reboot_action) {
Hridya Valsarajue4ef4532018-08-31 11:57:51 -0700340 // Save the usb state to restore after the sideload operation.
341 std::string usb_state = android::base::GetProperty("sys.usb.state", "none");
342 // Clean up state and stop adbd.
343 if (usb_state != "none" && !SetUsbConfig("none")) {
344 LOG(ERROR) << "Failed to clear USB config";
345 return INSTALL_ERROR;
346 }
Tao Bao682c34b2015-04-07 17:16:35 -0700347
xunchangfedeef62019-04-22 12:18:14 -0700348 RecoveryUI* ui = device->GetUI();
Doug Zongker9270a202012-01-09 15:16:13 -0800349
Tao Baoadc99ef2019-04-29 23:48:02 -0700350 InstallResult install_result = INSTALL_ERROR;
Tao Bao10f441a2019-04-19 15:22:15 -0700351 std::map<MinadbdCommand, CommandFunction> command_map{
Kelvin Zhanga4208b52022-02-14 18:38:06 -0800352 { MinadbdCommand::kInstall, std::bind(&AdbInstallPackageHandler, device, &install_result) },
Tao Bao10f441a2019-04-19 15:22:15 -0700353 { MinadbdCommand::kRebootAndroid, std::bind(&AdbRebootHandler, MinadbdCommand::kRebootAndroid,
354 &install_result, reboot_action) },
355 { MinadbdCommand::kRebootBootloader,
356 std::bind(&AdbRebootHandler, MinadbdCommand::kRebootBootloader, &install_result,
357 reboot_action) },
358 { MinadbdCommand::kRebootFastboot, std::bind(&AdbRebootHandler, MinadbdCommand::kRebootFastboot,
359 &install_result, reboot_action) },
360 { MinadbdCommand::kRebootRecovery, std::bind(&AdbRebootHandler, MinadbdCommand::kRebootRecovery,
361 &install_result, reboot_action) },
362 { MinadbdCommand::kRebootRescue,
363 std::bind(&AdbRebootHandler, MinadbdCommand::kRebootRescue, &install_result, reboot_action) },
xunchang34690ce2019-04-05 16:16:07 -0700364 };
Doug Zongker9270a202012-01-09 15:16:13 -0800365
xunchangfedeef62019-04-22 12:18:14 -0700366 if (!rescue_mode) {
367 ui->Print(
368 "\n\nNow send the package you want to apply\n"
369 "to the device with \"adb sideload <filename>\"...\n");
370 } else {
xunchangfedeef62019-04-22 12:18:14 -0700371 command_map.emplace(MinadbdCommand::kWipeData, [&device]() {
372 bool result = WipeData(device, false);
373 return std::make_pair(result, true);
374 });
Tao Bao2223e6a2019-07-08 18:07:22 -0700375 command_map.emplace(MinadbdCommand::kNoOp, []() { return std::make_pair(true, true); });
376
377 ui->Print("\n\nWaiting for rescue commands...\n");
xunchangfedeef62019-04-22 12:18:14 -0700378 }
379
Tao Baod9cb0142019-04-23 11:46:25 -0700380 CreateMinadbdServiceAndExecuteCommands(ui, command_map, rescue_mode);
Doug Zongker075ad802014-06-26 15:35:51 -0700381
Hridya Valsarajue4ef4532018-08-31 11:57:51 -0700382 // Clean up before switching to the older state, for example setting the state
383 // to none sets sys/class/android_usb/android0/enable to 0.
384 if (!SetUsbConfig("none")) {
385 LOG(ERROR) << "Failed to clear USB config";
386 }
387
388 if (usb_state != "none") {
389 if (!SetUsbConfig(usb_state)) {
390 LOG(ERROR) << "Failed to set USB config to " << usb_state;
391 }
392 }
Doug Zongker9270a202012-01-09 15:16:13 -0800393
xunchang34690ce2019-04-05 16:16:07 -0700394 return install_result;
Doug Zongker9270a202012-01-09 15:16:13 -0800395}