blob: 93c99e4e68bbe141d0bdcd199fb769f712ae69a0 [file] [log] [blame]
//
// Copyright (C) 2012 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 <inttypes.h>
#include <sysexits.h>
#include <unistd.h>
#include <string>
#include <base/bind.h>
#include <base/command_line.h>
#include <base/logging.h>
#include <base/macros.h>
#include <chromeos/daemons/dbus_daemon.h>
#include <chromeos/flag_helper.h>
#include <dbus/bus.h>
#include <update_engine/dbus-constants.h>
#include <update_engine/dbus-proxies.h>
using std::string;
using update_engine::kAttemptUpdateFlagNonInteractive;
using update_engine::kUpdateEngineServiceName;
namespace {
// Constant to signal that we need to continue running the daemon after
// initialization.
const int kContinueRunning = -1;
class UpdateEngineClient : public chromeos::DBusDaemon {
public:
UpdateEngineClient(int argc, char** argv) : argc_(argc), argv_(argv) {}
~UpdateEngineClient() override = default;
protected:
int OnInit() override {
int ret = DBusDaemon::OnInit();
if (ret != EX_OK)
return ret;
if (!InitProxy())
return 1;
// Wait for the UpdateEngine to be available or timeout.
proxy_->GetObjectProxy()->WaitForServiceToBeAvailable(
base::Bind(&UpdateEngineClient::OnServiceAvailable,
base::Unretained(this)));
base::MessageLoop::current()->PostDelayedTask(
FROM_HERE,
base::Bind(&UpdateEngineClient::OnServiceAvailableTimeout,
base::Unretained(this)),
base::TimeDelta::FromSeconds(10));
return EX_OK;
}
private:
bool InitProxy();
// Callback called when the UpdateEngine service becomes available.
void OnServiceAvailable(bool service_is_available);
// Callback called when the UpdateEngine service doesn't become available
// after a timeout.
void OnServiceAvailableTimeout();
// Callback called when a StatusUpdate signal is received.
void OnStatusUpdateSignal(int64_t last_checked_time,
double progress,
const string& current_operation,
const string& new_version,
int64_t new_size);
// Callback called when the OnStatusUpdateSignal() handler is registered.
void OnStatusUpdateSignalRegistration(const string& interface,
const string& signal_name,
bool success);
// Registers a callback that prints on stderr the received StatusUpdate
// signals.
// The daemon should continue running for this to work.
void WatchForUpdates();
void ResetStatus();
// Show the status of the update engine in stdout.
// Blocking call. Exits the program with error 1 in case of an error.
void ShowStatus();
// Return the current operation status, such as UPDATE_STATUS_IDLE.
// Blocking call. Exits the program with error 1 in case of an error.
string GetCurrentOperation();
void Rollback(bool rollback);
string GetRollbackPartition();
void CheckForUpdates(const string& app_version,
const string& omaha_url,
bool interactive);
// Reboot the device if a reboot is needed.
// Blocking call. Ignores failures.
void RebootIfNeeded();
// Getter and setter for the target channel. If |get_current_channel| is true,
// the current channel instead of the target channel will be returned.
// Blocking call. Exits the program with error 1 in case of an error.
void SetTargetChannel(const string& target_channel, bool allow_powerwash);
string GetChannel(bool get_current_channel);
// Getter and setter for the updates over cellular connections.
// Blocking call. Exits the program with error 1 in case of an error.
void SetUpdateOverCellularPermission(bool allowed);
bool GetUpdateOverCellularPermission();
// Getter and setter for the updates from P2P permission.
// Blocking call. Exits the program with error 1 in case of an error.
void SetP2PUpdatePermission(bool enabled);
bool GetP2PUpdatePermission();
// This is similar to watching for updates but rather than registering
// a signal watch, actively poll the daemon just in case it stops
// sending notifications.
void WaitForUpdateComplete();
void OnUpdateCompleteCheck(int64_t last_checked_time,
double progress,
const string& current_operation,
const string& new_version,
int64_t new_size);
// Blocking call. Exits the program with error 1 in case of an error.
void ShowPrevVersion();
// Returns whether the current status is such that a reboot is needed.
// Blocking call. Exits the program with error 1 in case of an error.
bool GetIsRebootNeeded();
// Blocks until a reboot is needed. If the reboot is needed, exits the program
// with 0. Otherwise it exits the program with 1 if an error occurs before
// the reboot is needed.
void WaitForRebootNeeded();
void OnRebootNeededCheck(int64_t last_checked_time,
double progress,
const string& current_operation,
const string& new_version,
int64_t new_size);
// Callback called when the OnRebootNeededCheck() handler is registered. This
// is useful to check at this point if the reboot is needed, without loosing
// any StatusUpdate signals and avoiding the race condition.
void OnRebootNeededCheckRegistration(const string& interface,
const string& signal_name,
bool success);
// Main method that parses and triggers all the actions based on the passed
// flags.
int ProcessFlags();
// DBus Proxy to the update_engine daemon object used for all the calls.
std::unique_ptr<org::chromium::UpdateEngineInterfaceProxy> proxy_;
// Copy of argc and argv passed to main().
int argc_;
char** argv_;
// Tell whether the UpdateEngine service is available after startup.
bool service_is_available_{false};
DISALLOW_COPY_AND_ASSIGN(UpdateEngineClient);
};
bool UpdateEngineClient::InitProxy() {
proxy_.reset(new org::chromium::UpdateEngineInterfaceProxy(bus_));
if (!proxy_->GetObjectProxy()) {
LOG(ERROR) << "Error getting dbus proxy for " << kUpdateEngineServiceName;
return false;
}
return true;
}
void UpdateEngineClient::OnServiceAvailable(bool service_is_available) {
service_is_available_ = service_is_available;
if (!service_is_available) {
LOG(ERROR) << "UpdateEngineService not available.";
QuitWithExitCode(-1);
}
int ret = ProcessFlags();
if (ret != kContinueRunning)
QuitWithExitCode(ret);
}
void UpdateEngineClient::OnServiceAvailableTimeout() {
if (!service_is_available_) {
LOG(ERROR) << "Waiting for UpdateEngineService timeout. Is update_engine "
"daemon running?";
QuitWithExitCode(-1);
}
}
void UpdateEngineClient::OnStatusUpdateSignal(
int64_t last_checked_time,
double progress,
const string& current_operation,
const string& new_version,
int64_t new_size) {
LOG(INFO) << "Got status update:";
LOG(INFO) << " last_checked_time: " << last_checked_time;
LOG(INFO) << " progress: " << progress;
LOG(INFO) << " current_operation: " << current_operation;
LOG(INFO) << " new_version: " << new_version;
LOG(INFO) << " new_size: " << new_size;
}
void UpdateEngineClient::OnStatusUpdateSignalRegistration(
const string& interface,
const string& signal_name,
bool success) {
VLOG(1) << "OnStatusUpdateSignalRegistration(" << interface << ", "
<< signal_name << ", " << success << ");";
if (!success) {
LOG(ERROR) << "Couldn't connect to the " << signal_name << " signal.";
exit(1);
}
}
void UpdateEngineClient::WatchForUpdates() {
proxy_->RegisterStatusUpdateSignalHandler(
base::Bind(&UpdateEngineClient::OnStatusUpdateSignal,
base::Unretained(this)),
base::Bind(&UpdateEngineClient::OnStatusUpdateSignalRegistration,
base::Unretained(this)));
}
void UpdateEngineClient::ResetStatus() {
bool ret = proxy_->ResetStatus(nullptr);
CHECK(ret) << "ResetStatus() failed.";
}
void UpdateEngineClient::ShowStatus() {
int64_t last_checked_time = 0;
double progress = 0.0;
string current_op;
string new_version;
int64_t new_size = 0;
bool ret = proxy_->GetStatus(
&last_checked_time, &progress, &current_op, &new_version, &new_size,
nullptr);
CHECK(ret) << "GetStatus() failed";
printf("LAST_CHECKED_TIME=%" PRIi64 "\nPROGRESS=%f\nCURRENT_OP=%s\n"
"NEW_VERSION=%s\nNEW_SIZE=%" PRIi64 "\n",
last_checked_time,
progress,
current_op.c_str(),
new_version.c_str(),
new_size);
}
string UpdateEngineClient::GetCurrentOperation() {
int64_t last_checked_time = 0;
double progress = 0.0;
string current_op;
string new_version;
int64_t new_size = 0;
bool ret = proxy_->GetStatus(
&last_checked_time, &progress, &current_op, &new_version, &new_size,
nullptr);
CHECK(ret) << "GetStatus() failed";
return current_op;
}
void UpdateEngineClient::Rollback(bool rollback) {
bool ret = proxy_->AttemptRollback(rollback, nullptr);
CHECK(ret) << "Rollback request failed.";
}
string UpdateEngineClient::GetRollbackPartition() {
string rollback_partition;
bool ret = proxy_->GetRollbackPartition(&rollback_partition, nullptr);
CHECK(ret) << "Error while querying rollback partition availabilty.";
return rollback_partition;
}
void UpdateEngineClient::CheckForUpdates(const string& app_version,
const string& omaha_url,
bool interactive) {
int32_t flags = interactive ? 0 : kAttemptUpdateFlagNonInteractive;
bool ret = proxy_->AttemptUpdateWithFlags(app_version, omaha_url, flags,
nullptr);
CHECK(ret) << "Error checking for update.";
}
void UpdateEngineClient::RebootIfNeeded() {
bool ret = proxy_->RebootIfNeeded(nullptr);
if (!ret) {
// Reboot error code doesn't necessarily mean that a reboot
// failed. For example, D-Bus may be shutdown before we receive the
// result.
LOG(INFO) << "RebootIfNeeded() failure ignored.";
}
}
void UpdateEngineClient::SetTargetChannel(const string& target_channel,
bool allow_powerwash) {
bool ret = proxy_->SetChannel(target_channel, allow_powerwash, nullptr);
CHECK(ret) << "Error setting the channel.";
LOG(INFO) << "Channel permanently set to: " << target_channel;
}
string UpdateEngineClient::GetChannel(bool get_current_channel) {
string channel;
bool ret = proxy_->GetChannel(get_current_channel, &channel, nullptr);
CHECK(ret) << "Error getting the channel.";
return channel;
}
void UpdateEngineClient::SetUpdateOverCellularPermission(bool allowed) {
bool ret = proxy_->SetUpdateOverCellularPermission(allowed, nullptr);
CHECK(ret) << "Error setting the update over cellular setting.";
}
bool UpdateEngineClient::GetUpdateOverCellularPermission() {
bool allowed;
bool ret = proxy_->GetUpdateOverCellularPermission(&allowed, nullptr);
CHECK(ret) << "Error getting the update over cellular setting.";
return allowed;
}
void UpdateEngineClient::SetP2PUpdatePermission(bool enabled) {
bool ret = proxy_->SetP2PUpdatePermission(enabled, nullptr);
CHECK(ret) << "Error setting the peer-to-peer update setting.";
}
bool UpdateEngineClient::GetP2PUpdatePermission() {
bool enabled;
bool ret = proxy_->GetP2PUpdatePermission(&enabled, nullptr);
CHECK(ret) << "Error getting the peer-to-peer update setting.";
return enabled;
}
void UpdateEngineClient::OnUpdateCompleteCheck(
int64_t /* last_checked_time */,
double /* progress */,
const string& current_operation,
const string& /* new_version */,
int64_t /* new_size */) {
if (current_operation == update_engine::kUpdateStatusIdle) {
LOG(ERROR) << "Update failed, current operations is " << current_operation;
exit(1);
}
if (current_operation == update_engine::kUpdateStatusUpdatedNeedReboot) {
LOG(INFO) << "Update succeeded -- reboot needed.";
exit(0);
}
}
void UpdateEngineClient::WaitForUpdateComplete() {
proxy_->RegisterStatusUpdateSignalHandler(
base::Bind(&UpdateEngineClient::OnUpdateCompleteCheck,
base::Unretained(this)),
base::Bind(&UpdateEngineClient::OnStatusUpdateSignalRegistration,
base::Unretained(this)));
}
void UpdateEngineClient::ShowPrevVersion() {
string prev_version = nullptr;
bool ret = proxy_->GetPrevVersion(&prev_version, nullptr);;
if (!ret) {
LOG(ERROR) << "Error getting previous version.";
} else {
LOG(INFO) << "Previous version = " << prev_version;
}
}
bool UpdateEngineClient::GetIsRebootNeeded() {
return GetCurrentOperation() == update_engine::kUpdateStatusUpdatedNeedReboot;
}
void UpdateEngineClient::OnRebootNeededCheck(
int64_t /* last_checked_time */,
double /* progress */,
const string& current_operation,
const string& /* new_version */,
int64_t /* new_size */) {
if (current_operation == update_engine::kUpdateStatusUpdatedNeedReboot) {
LOG(INFO) << "Reboot needed.";
exit(0);
}
}
void UpdateEngineClient::OnRebootNeededCheckRegistration(
const string& interface,
const string& signal_name,
bool success) {
if (GetIsRebootNeeded())
exit(0);
if (!success) {
LOG(ERROR) << "Couldn't connect to the " << signal_name << " signal.";
exit(1);
}
}
// Blocks until a reboot is needed. Returns true if waiting succeeded,
// false if an error occurred.
void UpdateEngineClient::WaitForRebootNeeded() {
proxy_->RegisterStatusUpdateSignalHandler(
base::Bind(&UpdateEngineClient::OnUpdateCompleteCheck,
base::Unretained(this)),
base::Bind(&UpdateEngineClient::OnStatusUpdateSignalRegistration,
base::Unretained(this)));
if (GetIsRebootNeeded())
exit(0);
}
int UpdateEngineClient::ProcessFlags() {
DEFINE_string(app_version, "", "Force the current app version.");
DEFINE_string(channel, "",
"Set the target channel. The device will be powerwashed if the "
"target channel is more stable than the current channel unless "
"--nopowerwash is specified.");
DEFINE_bool(check_for_update, false, "Initiate check for updates.");
DEFINE_bool(follow, false, "Wait for any update operations to complete."
"Exit status is 0 if the update succeeded, and 1 otherwise.");
DEFINE_bool(interactive, true, "Mark the update request as interactive.");
DEFINE_string(omaha_url, "", "The URL of the Omaha update server.");
DEFINE_string(p2p_update, "",
"Enables (\"yes\") or disables (\"no\") the peer-to-peer update"
" sharing.");
DEFINE_bool(powerwash, true, "When performing rollback or channel change, "
"do a powerwash or allow it respectively.");
DEFINE_bool(reboot, false, "Initiate a reboot if needed.");
DEFINE_bool(is_reboot_needed, false, "Exit status 0 if reboot is needed, "
"2 if reboot is not needed or 1 if an error occurred.");
DEFINE_bool(block_until_reboot_is_needed, false, "Blocks until reboot is "
"needed. Returns non-zero exit status if an error occurred.");
DEFINE_bool(reset_status, false, "Sets the status in update_engine to idle.");
DEFINE_bool(rollback, false,
"Perform a rollback to the previous partition. The device will "
"be powerwashed unless --nopowerwash is specified.");
DEFINE_bool(can_rollback, false, "Shows whether rollback partition "
"is available.");
DEFINE_bool(show_channel, false, "Show the current and target channels.");
DEFINE_bool(show_p2p_update, false,
"Show the current setting for peer-to-peer update sharing.");
DEFINE_bool(show_update_over_cellular, false,
"Show the current setting for updates over cellular networks.");
DEFINE_bool(status, false, "Print the status to stdout.");
DEFINE_bool(update, false, "Forces an update and waits for it to complete. "
"Implies --follow.");
DEFINE_string(update_over_cellular, "",
"Enables (\"yes\") or disables (\"no\") the updates over "
"cellular networks.");
DEFINE_bool(watch_for_updates, false,
"Listen for status updates and print them to the screen.");
DEFINE_bool(prev_version, false,
"Show the previous OS version used before the update reboot.");
// Boilerplate init commands.
base::CommandLine::Init(argc_, argv_);
chromeos::FlagHelper::Init(argc_, argv_, "Chromium OS Update Engine Client");
// Ensure there are no positional arguments.
const std::vector<string> positional_args =
base::CommandLine::ForCurrentProcess()->GetArgs();
if (!positional_args.empty()) {
LOG(ERROR) << "Found a positional argument '" << positional_args.front()
<< "'. If you want to pass a value to a flag, pass it as "
"--flag=value.";
return 1;
}
// Update the status if requested.
if (FLAGS_reset_status) {
LOG(INFO) << "Setting Update Engine status to idle ...";
ResetStatus();
LOG(INFO) << "ResetStatus succeeded; to undo partition table changes run:\n"
"(D=$(rootdev -d) P=$(rootdev -s); cgpt p -i$(($(echo ${P#$D} "
"| sed 's/^[^0-9]*//')-1)) $D;)";
}
// Changes the current update over cellular network setting.
if (!FLAGS_update_over_cellular.empty()) {
bool allowed = FLAGS_update_over_cellular == "yes";
if (!allowed && FLAGS_update_over_cellular != "no") {
LOG(ERROR) << "Unknown option: \"" << FLAGS_update_over_cellular
<< "\". Please specify \"yes\" or \"no\".";
} else {
SetUpdateOverCellularPermission(allowed);
}
}
// Show the current update over cellular network setting.
if (FLAGS_show_update_over_cellular) {
bool allowed = GetUpdateOverCellularPermission();
LOG(INFO) << "Current update over cellular network setting: "
<< (allowed ? "ENABLED" : "DISABLED");
}
if (!FLAGS_powerwash && !FLAGS_rollback && FLAGS_channel.empty()) {
LOG(ERROR) << "powerwash flag only makes sense rollback or channel change";
return 1;
}
// Change the P2P enabled setting.
if (!FLAGS_p2p_update.empty()) {
bool enabled = FLAGS_p2p_update == "yes";
if (!enabled && FLAGS_p2p_update != "no") {
LOG(ERROR) << "Unknown option: \"" << FLAGS_p2p_update
<< "\". Please specify \"yes\" or \"no\".";
} else {
SetP2PUpdatePermission(enabled);
}
}
// Show the rollback availability.
if (FLAGS_can_rollback) {
string rollback_partition = GetRollbackPartition();
bool can_rollback = true;
if (rollback_partition.empty()) {
rollback_partition = "UNAVAILABLE";
can_rollback = false;
} else {
rollback_partition = "AVAILABLE: " + rollback_partition;
}
LOG(INFO) << "Rollback partition: " << rollback_partition;
if (!can_rollback) {
return 1;
}
}
// Show the current P2P enabled setting.
if (FLAGS_show_p2p_update) {
bool enabled = GetP2PUpdatePermission();
LOG(INFO) << "Current update using P2P setting: "
<< (enabled ? "ENABLED" : "DISABLED");
}
// First, update the target channel if requested.
if (!FLAGS_channel.empty())
SetTargetChannel(FLAGS_channel, FLAGS_powerwash);
// Show the current and target channels if requested.
if (FLAGS_show_channel) {
string current_channel = GetChannel(true);
LOG(INFO) << "Current Channel: " << current_channel;
string target_channel = GetChannel(false);
if (!target_channel.empty())
LOG(INFO) << "Target Channel (pending update): " << target_channel;
}
bool do_update_request = FLAGS_check_for_update | FLAGS_update |
!FLAGS_app_version.empty() | !FLAGS_omaha_url.empty();
if (FLAGS_update)
FLAGS_follow = true;
if (do_update_request && FLAGS_rollback) {
LOG(ERROR) << "Incompatible flags specified with rollback."
<< "Rollback should not include update-related flags.";
return 1;
}
if (FLAGS_rollback) {
LOG(INFO) << "Requesting rollback.";
Rollback(FLAGS_powerwash);
}
// Initiate an update check, if necessary.
if (do_update_request) {
LOG_IF(WARNING, FLAGS_reboot) << "-reboot flag ignored.";
string app_version = FLAGS_app_version;
if (FLAGS_update && app_version.empty()) {
app_version = "ForcedUpdate";
LOG(INFO) << "Forcing an update by setting app_version to ForcedUpdate.";
}
LOG(INFO) << "Initiating update check and install.";
CheckForUpdates(app_version, FLAGS_omaha_url, FLAGS_interactive);
}
// These final options are all mutually exclusive with one another.
if (FLAGS_follow + FLAGS_watch_for_updates + FLAGS_reboot +
FLAGS_status + FLAGS_is_reboot_needed +
FLAGS_block_until_reboot_is_needed > 1) {
LOG(ERROR) << "Multiple exclusive options selected. "
<< "Select only one of --follow, --watch_for_updates, --reboot, "
<< "--is_reboot_needed, --block_until_reboot_is_needed, "
<< "or --status.";
return 1;
}
if (FLAGS_status) {
LOG(INFO) << "Querying Update Engine status...";
ShowStatus();
return 0;
}
if (FLAGS_follow) {
LOG(INFO) << "Waiting for update to complete.";
WaitForUpdateComplete();
return kContinueRunning;
}
if (FLAGS_watch_for_updates) {
LOG(INFO) << "Watching for status updates.";
WatchForUpdates();
return kContinueRunning;
}
if (FLAGS_reboot) {
LOG(INFO) << "Requesting a reboot...";
RebootIfNeeded();
return 0;
}
if (FLAGS_prev_version) {
ShowPrevVersion();
}
if (FLAGS_is_reboot_needed) {
// In case of error GetIsRebootNeeded() will exit with 1.
if (GetIsRebootNeeded()) {
return 0;
} else {
return 2;
}
}
if (FLAGS_block_until_reboot_is_needed) {
WaitForRebootNeeded();
return kContinueRunning;
}
return 0;
}
} // namespace
int main(int argc, char** argv) {
UpdateEngineClient client(argc, argv);
return client.Run();
}