263 lines
9.7 KiB
C++
263 lines
9.7 KiB
C++
/*
|
|
* Copyright (C) 2017 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "host/commands/run_cvd/server_loop.h"
|
|
|
|
#include <fruit/fruit.h>
|
|
#include <gflags/gflags.h>
|
|
#include <unistd.h>
|
|
#include <string>
|
|
|
|
#include "common/libs/fs/shared_buf.h"
|
|
#include "common/libs/utils/files.h"
|
|
#include "common/libs/utils/subprocess.h"
|
|
#include "host/commands/run_cvd/runner_defs.h"
|
|
#include "host/libs/config/cuttlefish_config.h"
|
|
#include "host/libs/config/data_image.h"
|
|
#include "host/libs/config/feature.h"
|
|
|
|
namespace cuttlefish {
|
|
|
|
namespace {
|
|
|
|
bool CreateQcowOverlay(const std::string& crosvm_path,
|
|
const std::string& backing_file,
|
|
const std::string& output_overlay_path) {
|
|
Command crosvm_qcow2_cmd(crosvm_path);
|
|
crosvm_qcow2_cmd.AddParameter("create_qcow2");
|
|
crosvm_qcow2_cmd.AddParameter("--backing_file=", backing_file);
|
|
crosvm_qcow2_cmd.AddParameter(output_overlay_path);
|
|
int success = crosvm_qcow2_cmd.Start().Wait();
|
|
if (success != 0) {
|
|
LOG(ERROR) << "Unable to run crosvm create_qcow2. Exited with status "
|
|
<< success;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
class ServerLoopImpl : public ServerLoop, public SetupFeature {
|
|
public:
|
|
INJECT(ServerLoopImpl(const CuttlefishConfig& config,
|
|
const CuttlefishConfig::InstanceSpecific& instance))
|
|
: config_(config), instance_(instance) {}
|
|
|
|
// ServerLoop
|
|
void Run(ProcessMonitor& process_monitor) override {
|
|
while (true) {
|
|
// TODO: use select to handle simultaneous connections.
|
|
auto client = SharedFD::Accept(*server_);
|
|
LauncherAction action;
|
|
while (client->IsOpen() && client->Read(&action, sizeof(action)) > 0) {
|
|
switch (action) {
|
|
case LauncherAction::kStop: {
|
|
auto stop = process_monitor.StopMonitoredProcesses();
|
|
if (stop.ok()) {
|
|
auto response = LauncherResponse::kSuccess;
|
|
client->Write(&response, sizeof(response));
|
|
std::exit(0);
|
|
} else {
|
|
LOG(ERROR) << "Failed to stop subprocesses:\n" << stop.error();
|
|
auto response = LauncherResponse::kError;
|
|
client->Write(&response, sizeof(response));
|
|
}
|
|
break;
|
|
}
|
|
case LauncherAction::kStatus: {
|
|
// TODO(schuffelen): Return more information on a side channel
|
|
auto response = LauncherResponse::kSuccess;
|
|
client->Write(&response, sizeof(response));
|
|
break;
|
|
}
|
|
case LauncherAction::kPowerwash: {
|
|
LOG(INFO) << "Received a Powerwash request from the monitor socket";
|
|
auto stop = process_monitor.StopMonitoredProcesses();
|
|
if (!stop.ok()) {
|
|
LOG(ERROR) << "Stopping processes failed:\n" << stop.error();
|
|
auto response = LauncherResponse::kError;
|
|
client->Write(&response, sizeof(response));
|
|
break;
|
|
}
|
|
if (!PowerwashFiles()) {
|
|
LOG(ERROR) << "Powerwashing files failed.";
|
|
auto response = LauncherResponse::kError;
|
|
client->Write(&response, sizeof(response));
|
|
break;
|
|
}
|
|
auto response = LauncherResponse::kSuccess;
|
|
client->Write(&response, sizeof(response));
|
|
|
|
RestartRunCvd(client->UNMANAGED_Dup());
|
|
// RestartRunCvd should not return, so something went wrong.
|
|
response = LauncherResponse::kError;
|
|
client->Write(&response, sizeof(response));
|
|
LOG(FATAL) << "run_cvd in a bad state";
|
|
break;
|
|
}
|
|
case LauncherAction::kRestart: {
|
|
auto stop = process_monitor.StopMonitoredProcesses();
|
|
if (!stop.ok()) {
|
|
LOG(ERROR) << "Stopping processes failed:\n" << stop.error();
|
|
auto response = LauncherResponse::kError;
|
|
client->Write(&response, sizeof(response));
|
|
break;
|
|
}
|
|
DeleteFifos();
|
|
|
|
auto response = LauncherResponse::kSuccess;
|
|
client->Write(&response, sizeof(response));
|
|
RestartRunCvd(client->UNMANAGED_Dup());
|
|
// RestartRunCvd should not return, so something went wrong.
|
|
response = LauncherResponse::kError;
|
|
client->Write(&response, sizeof(response));
|
|
LOG(FATAL) << "run_cvd in a bad state";
|
|
break;
|
|
}
|
|
default:
|
|
LOG(ERROR) << "Unrecognized launcher action: "
|
|
<< static_cast<char>(action);
|
|
auto response = LauncherResponse::kError;
|
|
client->Write(&response, sizeof(response));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// SetupFeature
|
|
std::string Name() const override { return "ServerLoop"; }
|
|
|
|
private:
|
|
bool Enabled() const override { return true; }
|
|
std::unordered_set<SetupFeature*> Dependencies() const override { return {}; }
|
|
bool Setup() {
|
|
auto launcher_monitor_path = instance_.launcher_monitor_socket_path();
|
|
server_ = SharedFD::SocketLocalServer(launcher_monitor_path.c_str(), false,
|
|
SOCK_STREAM, 0666);
|
|
if (!server_->IsOpen()) {
|
|
LOG(ERROR) << "Error when opening launcher server: "
|
|
<< server_->StrError();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void DeleteFifos() {
|
|
// TODO(schuffelen): Create these FIFOs in assemble_cvd instead of run_cvd.
|
|
std::vector<std::string> pipes = {
|
|
instance_.kernel_log_pipe_name(),
|
|
instance_.console_in_pipe_name(),
|
|
instance_.console_out_pipe_name(),
|
|
instance_.logcat_pipe_name(),
|
|
instance_.PerInstanceInternalPath("keymaster_fifo_vm.in"),
|
|
instance_.PerInstanceInternalPath("keymaster_fifo_vm.out"),
|
|
instance_.PerInstanceInternalPath("gatekeeper_fifo_vm.in"),
|
|
instance_.PerInstanceInternalPath("gatekeeper_fifo_vm.out"),
|
|
instance_.PerInstanceInternalPath("bt_fifo_vm.in"),
|
|
instance_.PerInstanceInternalPath("bt_fifo_vm.out"),
|
|
instance_.PerInstanceInternalPath("gnsshvc_fifo_vm.in"),
|
|
instance_.PerInstanceInternalPath("gnsshvc_fifo_vm.out"),
|
|
instance_.PerInstanceInternalPath("locationhvc_fifo_vm.in"),
|
|
instance_.PerInstanceInternalPath("locationhvc_fifo_vm.out"),
|
|
};
|
|
for (const auto& pipe : pipes) {
|
|
unlink(pipe.c_str());
|
|
}
|
|
}
|
|
|
|
bool PowerwashFiles() {
|
|
DeleteFifos();
|
|
|
|
// TODO(schuffelen): Clean up duplication with assemble_cvd
|
|
unlink(instance_.PerInstancePath("NVChip").c_str());
|
|
|
|
auto kregistry_path = instance_.access_kregistry_path();
|
|
unlink(kregistry_path.c_str());
|
|
CreateBlankImage(kregistry_path, 2 /* mb */, "none");
|
|
|
|
auto hwcomposer_pmem_path = instance_.hwcomposer_pmem_path();
|
|
unlink(hwcomposer_pmem_path.c_str());
|
|
CreateBlankImage(hwcomposer_pmem_path, 2 /* mb */, "none");
|
|
|
|
auto pstore_path = instance_.pstore_path();
|
|
unlink(pstore_path.c_str());
|
|
CreateBlankImage(pstore_path, 2 /* mb */, "none");
|
|
|
|
auto sdcard_path = instance_.sdcard_path();
|
|
auto sdcard_size = FileSize(sdcard_path);
|
|
unlink(sdcard_path.c_str());
|
|
// round up
|
|
auto sdcard_mb_size = (sdcard_size + (1 << 20) - 1) / (1 << 20);
|
|
LOG(DEBUG) << "Size in mb is " << sdcard_mb_size;
|
|
CreateBlankImage(sdcard_path, sdcard_mb_size, "sdcard");
|
|
std::vector<std::string> overlay_files{"overlay.img"};
|
|
if (instance_.start_ap()) {
|
|
overlay_files.emplace_back("ap_overlay.img");
|
|
}
|
|
for (auto overlay_file : {"overlay.img", "ap_overlay.img"}) {
|
|
auto overlay_path = instance_.PerInstancePath(overlay_file);
|
|
unlink(overlay_path.c_str());
|
|
if (!CreateQcowOverlay(config_.crosvm_binary(),
|
|
config_.os_composite_disk_path(), overlay_path)) {
|
|
LOG(ERROR) << "CreateQcowOverlay failed";
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void RestartRunCvd(int notification_fd) {
|
|
auto config_path = config_.AssemblyPath("cuttlefish_config.json");
|
|
auto followup_stdin = SharedFD::MemfdCreate("pseudo_stdin");
|
|
WriteAll(followup_stdin, config_path + "\n");
|
|
followup_stdin->LSeek(0, SEEK_SET);
|
|
followup_stdin->UNMANAGED_Dup2(0);
|
|
|
|
auto argv_vec = gflags::GetArgvs();
|
|
char** argv = new char*[argv_vec.size() + 2];
|
|
for (size_t i = 0; i < argv_vec.size(); i++) {
|
|
argv[i] = argv_vec[i].data();
|
|
}
|
|
// Will take precedence over any earlier arguments.
|
|
std::string reboot_notification =
|
|
"-reboot_notification_fd=" + std::to_string(notification_fd);
|
|
argv[argv_vec.size()] = reboot_notification.data();
|
|
argv[argv_vec.size() + 1] = nullptr;
|
|
|
|
execv("/proc/self/exe", argv);
|
|
// execve should not return, so something went wrong.
|
|
PLOG(ERROR) << "execv returned: ";
|
|
}
|
|
|
|
const CuttlefishConfig& config_;
|
|
const CuttlefishConfig::InstanceSpecific& instance_;
|
|
SharedFD server_;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
ServerLoop::~ServerLoop() = default;
|
|
|
|
fruit::Component<fruit::Required<const CuttlefishConfig,
|
|
const CuttlefishConfig::InstanceSpecific>,
|
|
ServerLoop>
|
|
serverLoopComponent() {
|
|
return fruit::createComponent()
|
|
.bind<ServerLoop, ServerLoopImpl>()
|
|
.addMultibinding<SetupFeature, ServerLoopImpl>();
|
|
}
|
|
|
|
} // namespace cuttlefish
|