blob: 348f3305f1d026625d5273d72964e40745e25a92 [file] [log] [blame]
Alex Deymo5e3ea272016-01-28 13:42:23 -08001//
2// Copyright (C) 2016 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
Amin Hassaniec7bc112020-10-29 16:47:58 -070017#include "update_engine/aosp/update_attempter_android.h"
Alex Deymo5e3ea272016-01-28 13:42:23 -080018
19#include <algorithm>
Alex Deymo218397f2016-02-04 23:55:10 -080020#include <map>
Tianjie Xu90aaa102017-10-10 17:39:03 -070021#include <memory>
Alex Deymo5e3ea272016-01-28 13:42:23 -080022#include <utility>
23
Tianjie Xu90aaa102017-10-10 17:39:03 -070024#include <android-base/properties.h>
Kyeongkab.Nam500ca132019-06-26 13:48:07 +090025#include <android-base/unique_fd.h>
Alex Deymo5e3ea272016-01-28 13:42:23 -080026#include <base/bind.h>
27#include <base/logging.h>
Alex Deymo218397f2016-02-04 23:55:10 -080028#include <base/strings/string_number_conversions.h>
Sen Jiang2703ef42017-03-16 13:36:21 -070029#include <brillo/data_encoding.h>
Alex Deymo5e3ea272016-01-28 13:42:23 -080030#include <brillo/message_loops/message_loop.h>
Alex Deymo218397f2016-02-04 23:55:10 -080031#include <brillo/strings/string_utils.h>
Sen Jiangacbdd1c2017-10-19 13:30:19 -070032#include <log/log_safetynet.h>
Alex Deymo5e3ea272016-01-28 13:42:23 -080033
Amin Hassaniec7bc112020-10-29 16:47:58 -070034#include "update_engine/aosp/cleanup_previous_update_action.h"
Alex Deymo5e3ea272016-01-28 13:42:23 -080035#include "update_engine/common/constants.h"
Amin Hassaniec7bc112020-10-29 16:47:58 -070036#include "update_engine/common/daemon_state_interface.h"
37#include "update_engine/common/download_action.h"
Sen Jiang8371c1c2018-02-01 13:46:39 -080038#include "update_engine/common/error_code_utils.h"
Alex Deymo2c131bb2016-05-26 16:43:13 -070039#include "update_engine/common/file_fetcher.h"
Amin Hassaniec7bc112020-10-29 16:47:58 -070040#include "update_engine/common/metrics_reporter_interface.h"
41#include "update_engine/common/network_selector.h"
Alex Deymo5e3ea272016-01-28 13:42:23 -080042#include "update_engine/common/utils.h"
Tianjie Xu1b661142017-09-28 14:03:42 -070043#include "update_engine/metrics_utils.h"
Tianjie Xu7a78d632019-10-08 16:32:39 -070044#include "update_engine/payload_consumer/certificate_parser_interface.h"
Sen Jiang8371c1c2018-02-01 13:46:39 -080045#include "update_engine/payload_consumer/delta_performer.h"
Sen Jiang8371c1c2018-02-01 13:46:39 -080046#include "update_engine/payload_consumer/file_descriptor.h"
47#include "update_engine/payload_consumer/file_descriptor_utils.h"
Alex Deymo5e3ea272016-01-28 13:42:23 -080048#include "update_engine/payload_consumer/filesystem_verifier_action.h"
Sen Jiang8371c1c2018-02-01 13:46:39 -080049#include "update_engine/payload_consumer/payload_constants.h"
50#include "update_engine/payload_consumer/payload_metadata.h"
Tianjie Xu7a78d632019-10-08 16:32:39 -070051#include "update_engine/payload_consumer/payload_verifier.h"
Alex Deymo5e3ea272016-01-28 13:42:23 -080052#include "update_engine/payload_consumer/postinstall_runner_action.h"
Amin Hassani667cf7b2018-07-25 14:32:00 -070053#include "update_engine/update_boot_flags_action.h"
Alex Deymo3b678db2016-02-09 11:50:06 -080054#include "update_engine/update_status_utils.h"
Alex Deymo5e3ea272016-01-28 13:42:23 -080055
Alex Deymo14c0da82016-07-20 16:45:45 -070056#ifndef _UE_SIDELOAD
57// Do not include support for external HTTP(s) urls when building
58// update_engine_sideload.
59#include "update_engine/libcurl_http_fetcher.h"
60#endif
61
Kyeongkab.Nam500ca132019-06-26 13:48:07 +090062using android::base::unique_fd;
Alex Deymo5e3ea272016-01-28 13:42:23 -080063using base::Bind;
Tianjie Xu90aaa102017-10-10 17:39:03 -070064using base::Time;
Alex Deymo5e3ea272016-01-28 13:42:23 -080065using base::TimeDelta;
66using base::TimeTicks;
67using std::shared_ptr;
68using std::string;
69using std::vector;
Aaron Wood7f92e2b2017-08-28 14:51:21 -070070using update_engine::UpdateEngineStatus;
Alex Deymo5e3ea272016-01-28 13:42:23 -080071
72namespace chromeos_update_engine {
73
74namespace {
75
Alex Deymo0d298542016-03-30 18:31:49 -070076// Minimum threshold to broadcast an status update in progress and time.
77const double kBroadcastThresholdProgress = 0.01; // 1%
78const int kBroadcastThresholdSeconds = 10;
79
Alex Deymo5e3ea272016-01-28 13:42:23 -080080const char* const kErrorDomain = "update_engine";
81// TODO(deymo): Convert the different errors to a numeric value to report them
82// back on the service error.
83const char* const kGenericError = "generic_error";
84
85// Log and set the error on the passed ErrorPtr.
86bool LogAndSetError(brillo::ErrorPtr* error,
Jakub Pawlowski7e1dcf72018-07-26 00:29:42 -070087 const base::Location& location,
Alex Deymo5e3ea272016-01-28 13:42:23 -080088 const string& reason) {
89 brillo::Error::AddTo(error, location, kErrorDomain, kGenericError, reason);
90 LOG(ERROR) << "Replying with failure: " << location.ToString() << ": "
91 << reason;
92 return false;
93}
94
Sen Jiangfe522822017-10-31 15:14:11 -070095bool GetHeaderAsBool(const string& header, bool default_value) {
96 int value = 0;
97 if (base::StringToInt(header, &value) && (value == 0 || value == 1))
98 return value == 1;
99 return default_value;
100}
101
Yifan Hongbd47d622019-12-13 14:59:58 -0800102bool ParseKeyValuePairHeaders(const vector<string>& key_value_pair_headers,
103 std::map<string, string>* headers,
104 brillo::ErrorPtr* error) {
105 for (const string& key_value_pair : key_value_pair_headers) {
106 string key;
107 string value;
108 if (!brillo::string_utils::SplitAtFirst(
109 key_value_pair, "=", &key, &value, false)) {
110 return LogAndSetError(
111 error, FROM_HERE, "Passed invalid header: " + key_value_pair);
112 }
113 if (!headers->emplace(key, value).second)
114 return LogAndSetError(error, FROM_HERE, "Passed repeated key: " + key);
115 }
116 return true;
117}
118
119// Unique identifier for the payload. An empty string means that the payload
120// can't be resumed.
121string GetPayloadId(const std::map<string, string>& headers) {
122 return (headers.count(kPayloadPropertyFileHash)
123 ? headers.at(kPayloadPropertyFileHash)
124 : "") +
125 (headers.count(kPayloadPropertyMetadataHash)
126 ? headers.at(kPayloadPropertyMetadataHash)
127 : "");
128}
129
Alex Deymo5e3ea272016-01-28 13:42:23 -0800130} // namespace
131
132UpdateAttempterAndroid::UpdateAttempterAndroid(
Alex Deymo03a4de72016-07-20 16:08:23 -0700133 DaemonStateInterface* daemon_state,
Alex Deymo5e3ea272016-01-28 13:42:23 -0800134 PrefsInterface* prefs,
135 BootControlInterface* boot_control,
136 HardwareInterface* hardware)
137 : daemon_state_(daemon_state),
138 prefs_(prefs),
139 boot_control_(boot_control),
140 hardware_(hardware),
Tianjie Xu1b661142017-09-28 14:03:42 -0700141 processor_(new ActionProcessor()),
Tianjie Xud4c5deb2017-10-24 11:17:03 -0700142 clock_(new Clock()) {
143 metrics_reporter_ = metrics::CreateMetricsReporter();
Alex Deymo87792ea2016-07-25 15:40:36 -0700144 network_selector_ = network::CreateNetworkSelector();
Alex Deymo5e3ea272016-01-28 13:42:23 -0800145}
146
147UpdateAttempterAndroid::~UpdateAttempterAndroid() {
148 // Release ourselves as the ActionProcessor's delegate to prevent
149 // re-scheduling the updates due to the processing stopped.
150 processor_->set_delegate(nullptr);
151}
152
153void UpdateAttempterAndroid::Init() {
154 // In case of update_engine restart without a reboot we need to restore the
155 // reboot needed state.
Tianjie Xu90aaa102017-10-10 17:39:03 -0700156 if (UpdateCompletedOnThisBoot()) {
Alex Deymo0e061ae2016-02-09 17:49:03 -0800157 SetStatusAndNotify(UpdateStatus::UPDATED_NEED_REBOOT);
Tianjie Xu90aaa102017-10-10 17:39:03 -0700158 } else {
Alex Deymo0e061ae2016-02-09 17:49:03 -0800159 SetStatusAndNotify(UpdateStatus::IDLE);
Tianjie Xu90aaa102017-10-10 17:39:03 -0700160 UpdatePrefsAndReportUpdateMetricsOnReboot();
Yifan Hong5cd63fa2020-03-16 12:31:16 -0700161#ifdef _UE_SIDELOAD
162 LOG(INFO) << "Skip ScheduleCleanupPreviousUpdate in sideload because "
163 << "ApplyPayload will call it later.";
164#else
Yifan Hong90965502020-02-19 15:22:47 -0800165 ScheduleCleanupPreviousUpdate();
Yifan Hong5cd63fa2020-03-16 12:31:16 -0700166#endif
Tianjie Xu90aaa102017-10-10 17:39:03 -0700167 }
Alex Deymo5e3ea272016-01-28 13:42:23 -0800168}
169
170bool UpdateAttempterAndroid::ApplyPayload(
171 const string& payload_url,
172 int64_t payload_offset,
173 int64_t payload_size,
174 const vector<string>& key_value_pair_headers,
175 brillo::ErrorPtr* error) {
176 if (status_ == UpdateStatus::UPDATED_NEED_REBOOT) {
177 return LogAndSetError(
178 error, FROM_HERE, "An update already applied, waiting for reboot");
179 }
Sen Jiang91f8d2a2018-07-12 14:27:04 -0700180 if (processor_->IsRunning()) {
Alex Deymo5e3ea272016-01-28 13:42:23 -0800181 return LogAndSetError(
182 error, FROM_HERE, "Already processing an update, cancel it first.");
183 }
184 DCHECK(status_ == UpdateStatus::IDLE);
185
Alex Deymo218397f2016-02-04 23:55:10 -0800186 std::map<string, string> headers;
Yifan Hongbd47d622019-12-13 14:59:58 -0800187 if (!ParseKeyValuePairHeaders(key_value_pair_headers, &headers, error)) {
188 return false;
Alex Deymo218397f2016-02-04 23:55:10 -0800189 }
190
Yifan Hongbd47d622019-12-13 14:59:58 -0800191 string payload_id = GetPayloadId(headers);
Alex Deymo5e3ea272016-01-28 13:42:23 -0800192
193 // Setup the InstallPlan based on the request.
194 install_plan_ = InstallPlan();
195
196 install_plan_.download_url = payload_url;
197 install_plan_.version = "";
Alex Deymo0fd51ff2016-02-03 14:22:43 -0800198 base_offset_ = payload_offset;
Sen Jiang0affc2c2017-02-10 15:55:05 -0800199 InstallPlan::Payload payload;
200 payload.size = payload_size;
201 if (!payload.size) {
Alex Deymo218397f2016-02-04 23:55:10 -0800202 if (!base::StringToUint64(headers[kPayloadPropertyFileSize],
Sen Jiang0affc2c2017-02-10 15:55:05 -0800203 &payload.size)) {
204 payload.size = 0;
Alex Deymo218397f2016-02-04 23:55:10 -0800205 }
206 }
Sen Jiang2703ef42017-03-16 13:36:21 -0700207 if (!brillo::data_encoding::Base64Decode(headers[kPayloadPropertyFileHash],
Sen Jiang0affc2c2017-02-10 15:55:05 -0800208 &payload.hash)) {
Sen Jiang2703ef42017-03-16 13:36:21 -0700209 LOG(WARNING) << "Unable to decode base64 file hash: "
210 << headers[kPayloadPropertyFileHash];
211 }
Alex Deymo218397f2016-02-04 23:55:10 -0800212 if (!base::StringToUint64(headers[kPayloadPropertyMetadataSize],
Sen Jiang0affc2c2017-02-10 15:55:05 -0800213 &payload.metadata_size)) {
214 payload.metadata_size = 0;
Alex Deymo218397f2016-02-04 23:55:10 -0800215 }
Sen Jiangcdd52062017-05-18 15:33:10 -0700216 // The |payload.type| is not used anymore since minor_version 3.
217 payload.type = InstallPayloadType::kUnknown;
Sen Jiang0affc2c2017-02-10 15:55:05 -0800218 install_plan_.payloads.push_back(payload);
219
Alex Deymo5e3ea272016-01-28 13:42:23 -0800220 // The |public_key_rsa| key would override the public key stored on disk.
221 install_plan_.public_key_rsa = "";
222
223 install_plan_.hash_checks_mandatory = hardware_->IsOfficialBuild();
224 install_plan_.is_resume = !payload_id.empty() &&
225 DeltaPerformer::CanResumeUpdate(prefs_, payload_id);
226 if (!install_plan_.is_resume) {
Yifan Hong55c2bfe2020-01-13 17:01:19 -0800227 // No need to reset dynamic_partititon_metadata_updated. If previous calls
228 // to AllocateSpaceForPayload uses the same payload_id, reuse preallocated
229 // space. Otherwise, DeltaPerformer re-allocates space when the payload is
230 // applied.
231 if (!DeltaPerformer::ResetUpdateProgress(
232 prefs_,
233 false /* quick */,
234 true /* skip_dynamic_partititon_metadata_updated */)) {
Alex Deymo5e3ea272016-01-28 13:42:23 -0800235 LOG(WARNING) << "Unable to reset the update progress.";
236 }
237 if (!prefs_->SetString(kPrefsUpdateCheckResponseHash, payload_id)) {
238 LOG(WARNING) << "Unable to save the update check response hash.";
239 }
240 }
Yifan Hongbd47d622019-12-13 14:59:58 -0800241 install_plan_.source_slot = GetCurrentSlot();
242 install_plan_.target_slot = GetTargetSlot();
Alex Deymofb905d92016-06-03 19:26:58 -0700243
Alex Deymofb905d92016-06-03 19:26:58 -0700244 install_plan_.powerwash_required =
Sen Jiangfe522822017-10-31 15:14:11 -0700245 GetHeaderAsBool(headers[kPayloadPropertyPowerwash], false);
246
247 install_plan_.switch_slot_on_reboot =
248 GetHeaderAsBool(headers[kPayloadPropertySwitchSlotOnReboot], true);
249
Tianjie Xu087de9d2019-11-01 17:11:22 -0700250 install_plan_.run_post_install =
251 GetHeaderAsBool(headers[kPayloadPropertyRunPostInstall], true);
Alex Deymo5e3ea272016-01-28 13:42:23 -0800252
Sen Jiang3eeaf7d2018-10-11 13:55:32 -0700253 // Skip writing verity if we're resuming and verity has already been written.
254 install_plan_.write_verity = true;
255 if (install_plan_.is_resume && prefs_->Exists(kPrefsVerityWritten)) {
256 bool verity_written = false;
257 if (prefs_->GetBoolean(kPrefsVerityWritten, &verity_written) &&
258 verity_written) {
259 install_plan_.write_verity = false;
260 }
261 }
262
Alex Deymo87792ea2016-07-25 15:40:36 -0700263 NetworkId network_id = kDefaultNetworkId;
264 if (!headers[kPayloadPropertyNetworkId].empty()) {
265 if (!base::StringToUint64(headers[kPayloadPropertyNetworkId],
266 &network_id)) {
267 return LogAndSetError(
268 error,
269 FROM_HERE,
270 "Invalid network_id: " + headers[kPayloadPropertyNetworkId]);
271 }
272 if (!network_selector_->SetProcessNetwork(network_id)) {
Sen Jiangcbd37c62017-09-12 15:04:35 -0700273 return LogAndSetError(
274 error,
275 FROM_HERE,
276 "Unable to set network_id: " + headers[kPayloadPropertyNetworkId]);
Alex Deymo87792ea2016-07-25 15:40:36 -0700277 }
278 }
279
Alex Deymo5e3ea272016-01-28 13:42:23 -0800280 install_plan_.Dump();
281
Amin Hassani667cf7b2018-07-25 14:32:00 -0700282 HttpFetcher* fetcher = nullptr;
283 if (FileFetcher::SupportedUrl(payload_url)) {
284 DLOG(INFO) << "Using FileFetcher for file URL.";
285 fetcher = new FileFetcher();
286 } else {
287#ifdef _UE_SIDELOAD
288 LOG(FATAL) << "Unsupported sideload URI: " << payload_url;
289#else
290 LibcurlHttpFetcher* libcurl_fetcher =
291 new LibcurlHttpFetcher(&proxy_resolver_, hardware_);
292 libcurl_fetcher->set_server_to_check(ServerToCheck::kDownload);
293 fetcher = libcurl_fetcher;
294#endif // _UE_SIDELOAD
295 }
Alex Deymofdd6dec2016-03-03 22:35:43 -0800296 // Setup extra headers.
Alex Deymofdd6dec2016-03-03 22:35:43 -0800297 if (!headers[kPayloadPropertyAuthorization].empty())
298 fetcher->SetHeader("Authorization", headers[kPayloadPropertyAuthorization]);
299 if (!headers[kPayloadPropertyUserAgent].empty())
300 fetcher->SetHeader("User-Agent", headers[kPayloadPropertyUserAgent]);
301
Amin Hassani667cf7b2018-07-25 14:32:00 -0700302 BuildUpdateActions(fetcher);
Alex Deymo5e3ea272016-01-28 13:42:23 -0800303
Alex Deymo5e3ea272016-01-28 13:42:23 -0800304 SetStatusAndNotify(UpdateStatus::UPDATE_AVAILABLE);
Tianjie Xu90aaa102017-10-10 17:39:03 -0700305
306 UpdatePrefsOnUpdateStart(install_plan_.is_resume);
307 // TODO(xunchang) report the metrics for unresumable updates
308
Amin Hassani667cf7b2018-07-25 14:32:00 -0700309 ScheduleProcessingStart();
Alex Deymo5e3ea272016-01-28 13:42:23 -0800310 return true;
311}
312
Kyeongkab.Nam500ca132019-06-26 13:48:07 +0900313bool UpdateAttempterAndroid::ApplyPayload(
314 int fd,
315 int64_t payload_offset,
316 int64_t payload_size,
317 const vector<string>& key_value_pair_headers,
318 brillo::ErrorPtr* error) {
319 payload_fd_.reset(dup(fd));
320 const string payload_url = "fd://" + std::to_string(payload_fd_.get());
321
322 return ApplyPayload(
323 payload_url, payload_offset, payload_size, key_value_pair_headers, error);
324}
325
Alex Deymo5e3ea272016-01-28 13:42:23 -0800326bool UpdateAttempterAndroid::SuspendUpdate(brillo::ErrorPtr* error) {
Sen Jiang91f8d2a2018-07-12 14:27:04 -0700327 if (!processor_->IsRunning())
Alex Deymof2858572016-02-25 11:20:13 -0800328 return LogAndSetError(error, FROM_HERE, "No ongoing update to suspend.");
329 processor_->SuspendProcessing();
330 return true;
Alex Deymo5e3ea272016-01-28 13:42:23 -0800331}
332
333bool UpdateAttempterAndroid::ResumeUpdate(brillo::ErrorPtr* error) {
Sen Jiang91f8d2a2018-07-12 14:27:04 -0700334 if (!processor_->IsRunning())
Alex Deymof2858572016-02-25 11:20:13 -0800335 return LogAndSetError(error, FROM_HERE, "No ongoing update to resume.");
336 processor_->ResumeProcessing();
337 return true;
Alex Deymo5e3ea272016-01-28 13:42:23 -0800338}
339
340bool UpdateAttempterAndroid::CancelUpdate(brillo::ErrorPtr* error) {
Sen Jiang91f8d2a2018-07-12 14:27:04 -0700341 if (!processor_->IsRunning())
Alex Deymo5e3ea272016-01-28 13:42:23 -0800342 return LogAndSetError(error, FROM_HERE, "No ongoing update to cancel.");
Alex Deymof2858572016-02-25 11:20:13 -0800343 processor_->StopProcessing();
344 return true;
Alex Deymo5e3ea272016-01-28 13:42:23 -0800345}
346
Alex Deymo3b678db2016-02-09 11:50:06 -0800347bool UpdateAttempterAndroid::ResetStatus(brillo::ErrorPtr* error) {
348 LOG(INFO) << "Attempting to reset state from "
349 << UpdateStatusToString(status_) << " to UpdateStatus::IDLE";
350
351 switch (status_) {
Yifan Hong6a6d0f12020-03-11 13:20:52 -0700352 case UpdateStatus::IDLE: {
353 if (!boot_control_->GetDynamicPartitionControl()->ResetUpdate(prefs_)) {
354 LOG(WARNING) << "Failed to reset snapshots. UpdateStatus is IDLE but"
355 << "space might not be freed.";
356 }
Alex Deymo3b678db2016-02-09 11:50:06 -0800357 return true;
Yifan Hong6a6d0f12020-03-11 13:20:52 -0700358 }
Alex Deymo3b678db2016-02-09 11:50:06 -0800359
Amin Hassani7cc8bb02019-01-14 16:29:47 -0800360 case UpdateStatus::UPDATED_NEED_REBOOT: {
Yifan Hong6a6d0f12020-03-11 13:20:52 -0700361 bool ret_value = true;
Alex Deymo3b678db2016-02-09 11:50:06 -0800362
363 // Update the boot flags so the current slot has higher priority.
Yifan Hongbd47d622019-12-13 14:59:58 -0800364 if (!boot_control_->SetActiveBootSlot(GetCurrentSlot()))
Alex Deymo3b678db2016-02-09 11:50:06 -0800365 ret_value = false;
366
Alex Deymo52590332016-11-29 18:29:13 -0800367 // Mark the current slot as successful again, since marking it as active
368 // may reset the successful bit. We ignore the result of whether marking
369 // the current slot as successful worked.
Amin Hassani7cc8bb02019-01-14 16:29:47 -0800370 if (!boot_control_->MarkBootSuccessfulAsync(Bind([](bool successful) {})))
Alex Deymo52590332016-11-29 18:29:13 -0800371 ret_value = false;
372
Tianjie Xud6aa91f2019-11-14 11:55:10 -0800373 // Resets the warm reset property since we won't switch the slot.
374 hardware_->SetWarmReset(false);
375
Yifan Hong6a6d0f12020-03-11 13:20:52 -0700376 // Remove update progress for DeltaPerformer and remove snapshots.
377 if (!boot_control_->GetDynamicPartitionControl()->ResetUpdate(prefs_))
378 ret_value = false;
379
380 // Remove the reboot marker so that if the machine is rebooted
381 // after resetting to idle state, it doesn't go back to
382 // UpdateStatus::UPDATED_NEED_REBOOT state.
383 if (!prefs_->Delete(kPrefsUpdateCompletedOnBootId))
384 ret_value = false;
385 ClearMetricsPrefs();
386
Alex Deymo3b678db2016-02-09 11:50:06 -0800387 if (!ret_value) {
388 return LogAndSetError(
Amin Hassani7cc8bb02019-01-14 16:29:47 -0800389 error, FROM_HERE, "Failed to reset the status to ");
Alex Deymo3b678db2016-02-09 11:50:06 -0800390 }
391
392 SetStatusAndNotify(UpdateStatus::IDLE);
393 LOG(INFO) << "Reset status successful";
394 return true;
395 }
396
397 default:
398 return LogAndSetError(
399 error,
400 FROM_HERE,
401 "Reset not allowed in this state. Cancel the ongoing update first");
402 }
403}
404
Yifan Hongbd47d622019-12-13 14:59:58 -0800405bool UpdateAttempterAndroid::VerifyPayloadParseManifest(
406 const std::string& metadata_filename,
407 DeltaArchiveManifest* manifest,
408 brillo::ErrorPtr* error) {
Sen Jiang8371c1c2018-02-01 13:46:39 -0800409 FileDescriptorPtr fd(new EintrSafeFileDescriptor);
410 if (!fd->Open(metadata_filename.c_str(), O_RDONLY)) {
411 return LogAndSetError(
412 error, FROM_HERE, "Failed to open " + metadata_filename);
413 }
414 brillo::Blob metadata(kMaxPayloadHeaderSize);
415 if (!fd->Read(metadata.data(), metadata.size())) {
416 return LogAndSetError(
417 error,
418 FROM_HERE,
419 "Failed to read payload header from " + metadata_filename);
420 }
421 ErrorCode errorcode;
422 PayloadMetadata payload_metadata;
Sen Jiangf1236632018-05-11 16:03:23 -0700423 if (payload_metadata.ParsePayloadHeader(metadata, &errorcode) !=
Sen Jiang8371c1c2018-02-01 13:46:39 -0800424 MetadataParseResult::kSuccess) {
425 return LogAndSetError(error,
426 FROM_HERE,
427 "Failed to parse payload header: " +
428 utils::ErrorCodeToString(errorcode));
429 }
Sen Jiang840a7ea2018-09-19 14:29:44 -0700430 uint64_t metadata_size = payload_metadata.GetMetadataSize() +
431 payload_metadata.GetMetadataSignatureSize();
432 if (metadata_size < kMaxPayloadHeaderSize ||
433 metadata_size >
434 static_cast<uint64_t>(utils::FileSize(metadata_filename))) {
Sen Jiang8371c1c2018-02-01 13:46:39 -0800435 return LogAndSetError(
436 error,
437 FROM_HERE,
Sen Jiang840a7ea2018-09-19 14:29:44 -0700438 "Invalid metadata size: " + std::to_string(metadata_size));
Sen Jiang8371c1c2018-02-01 13:46:39 -0800439 }
Sen Jiang840a7ea2018-09-19 14:29:44 -0700440 metadata.resize(metadata_size);
Sen Jiang8371c1c2018-02-01 13:46:39 -0800441 if (!fd->Read(metadata.data() + kMaxPayloadHeaderSize,
442 metadata.size() - kMaxPayloadHeaderSize)) {
443 return LogAndSetError(
444 error,
445 FROM_HERE,
446 "Failed to read metadata and signature from " + metadata_filename);
447 }
448 fd->Close();
Sen Jiang08c6da12019-01-07 18:28:56 -0800449
Tianjie Xu7a78d632019-10-08 16:32:39 -0700450 auto payload_verifier = PayloadVerifier::CreateInstanceFromZipPath(
451 constants::kUpdateCertificatesPath);
452 if (!payload_verifier) {
453 return LogAndSetError(error,
454 FROM_HERE,
455 "Failed to create the payload verifier from " +
456 std::string(constants::kUpdateCertificatesPath));
Sen Jiang08c6da12019-01-07 18:28:56 -0800457 }
Tianjie Xu7a78d632019-10-08 16:32:39 -0700458 errorcode = payload_metadata.ValidateMetadataSignature(
459 metadata, "", *payload_verifier);
Sen Jiang8371c1c2018-02-01 13:46:39 -0800460 if (errorcode != ErrorCode::kSuccess) {
461 return LogAndSetError(error,
462 FROM_HERE,
463 "Failed to validate metadata signature: " +
464 utils::ErrorCodeToString(errorcode));
465 }
Yifan Hongbd47d622019-12-13 14:59:58 -0800466 if (!payload_metadata.GetManifest(metadata, manifest)) {
Sen Jiang8371c1c2018-02-01 13:46:39 -0800467 return LogAndSetError(error, FROM_HERE, "Failed to parse manifest.");
468 }
469
Yifan Hongbd47d622019-12-13 14:59:58 -0800470 return true;
471}
472
473bool UpdateAttempterAndroid::VerifyPayloadApplicable(
474 const std::string& metadata_filename, brillo::ErrorPtr* error) {
475 DeltaArchiveManifest manifest;
476 TEST_AND_RETURN_FALSE(
477 VerifyPayloadParseManifest(metadata_filename, &manifest, error));
478
479 FileDescriptorPtr fd(new EintrSafeFileDescriptor);
480 ErrorCode errorcode;
481
482 BootControlInterface::Slot current_slot = GetCurrentSlot();
Sen Jiang8371c1c2018-02-01 13:46:39 -0800483 for (const PartitionUpdate& partition : manifest.partitions()) {
484 if (!partition.has_old_partition_info())
485 continue;
486 string partition_path;
487 if (!boot_control_->GetPartitionDevice(
488 partition.partition_name(), current_slot, &partition_path)) {
489 return LogAndSetError(
490 error,
491 FROM_HERE,
492 "Failed to get partition device for " + partition.partition_name());
493 }
494 if (!fd->Open(partition_path.c_str(), O_RDONLY)) {
495 return LogAndSetError(
496 error, FROM_HERE, "Failed to open " + partition_path);
497 }
498 for (const InstallOperation& operation : partition.operations()) {
499 if (!operation.has_src_sha256_hash())
500 continue;
501 brillo::Blob source_hash;
502 if (!fd_utils::ReadAndHashExtents(fd,
503 operation.src_extents(),
504 manifest.block_size(),
505 &source_hash)) {
506 return LogAndSetError(
507 error, FROM_HERE, "Failed to hash " + partition_path);
508 }
509 if (!DeltaPerformer::ValidateSourceHash(
510 source_hash, operation, fd, &errorcode)) {
511 return false;
512 }
513 }
514 fd->Close();
515 }
516 return true;
517}
518
Alex Deymo5e3ea272016-01-28 13:42:23 -0800519void UpdateAttempterAndroid::ProcessingDone(const ActionProcessor* processor,
520 ErrorCode code) {
521 LOG(INFO) << "Processing Done.";
522
Yifan Hong90965502020-02-19 15:22:47 -0800523 if (status_ == UpdateStatus::CLEANUP_PREVIOUS_UPDATE) {
524 TerminateUpdateAndNotify(code);
525 return;
526 }
527
Alex Deymo5990bf32016-07-19 17:01:41 -0700528 switch (code) {
529 case ErrorCode::kSuccess:
530 // Update succeeded.
531 WriteUpdateCompletedMarker();
532 prefs_->SetInt64(kPrefsDeltaUpdateFailures, 0);
Alex Deymo5e3ea272016-01-28 13:42:23 -0800533
Alex Deymo5990bf32016-07-19 17:01:41 -0700534 LOG(INFO) << "Update successfully applied, waiting to reboot.";
535 break;
536
537 case ErrorCode::kFilesystemCopierError:
538 case ErrorCode::kNewRootfsVerificationError:
539 case ErrorCode::kNewKernelVerificationError:
540 case ErrorCode::kFilesystemVerifierError:
541 case ErrorCode::kDownloadStateInitializationError:
542 // Reset the ongoing update for these errors so it starts from the
543 // beginning next time.
544 DeltaPerformer::ResetUpdateProgress(prefs_, false);
545 LOG(INFO) << "Resetting update progress.";
546 break;
547
Sen Jiangacbdd1c2017-10-19 13:30:19 -0700548 case ErrorCode::kPayloadTimestampError:
549 // SafetyNet logging, b/36232423
550 android_errorWriteLog(0x534e4554, "36232423");
551 break;
552
Alex Deymo5990bf32016-07-19 17:01:41 -0700553 default:
554 // Ignore all other error codes.
555 break;
Alex Deymo03a4de72016-07-20 16:08:23 -0700556 }
Alex Deymo5e3ea272016-01-28 13:42:23 -0800557
558 TerminateUpdateAndNotify(code);
559}
560
561void UpdateAttempterAndroid::ProcessingStopped(
562 const ActionProcessor* processor) {
563 TerminateUpdateAndNotify(ErrorCode::kUserCanceled);
564}
565
566void UpdateAttempterAndroid::ActionCompleted(ActionProcessor* processor,
567 AbstractAction* action,
568 ErrorCode code) {
569 // Reset download progress regardless of whether or not the download
570 // action succeeded.
571 const string type = action->Type();
Yifan Hong40bb0d02020-02-24 17:33:14 -0800572 if (type == CleanupPreviousUpdateAction::StaticType() ||
573 (type == NoOpAction::StaticType() &&
574 status_ == UpdateStatus::CLEANUP_PREVIOUS_UPDATE)) {
575 cleanup_previous_update_code_ = code;
576 NotifyCleanupPreviousUpdateCallbacksAndClear();
577 }
Kelvin Zhang70eef232020-06-12 20:32:40 +0000578 // download_progress_ is actually used by other actions, such as
579 // filesystem_verify_action. Therefore we always clear it.
580 download_progress_ = 0;
Sen Jiangfe522822017-10-31 15:14:11 -0700581 if (type == PostinstallRunnerAction::StaticType()) {
582 bool succeeded =
583 code == ErrorCode::kSuccess || code == ErrorCode::kUpdatedButNotActive;
584 prefs_->SetBoolean(kPrefsPostInstallSucceeded, succeeded);
585 }
Alex Deymo5e3ea272016-01-28 13:42:23 -0800586 if (code != ErrorCode::kSuccess) {
587 // If an action failed, the ActionProcessor will cancel the whole thing.
588 return;
589 }
Yifan Hong83517502020-02-19 15:34:13 -0800590 if (type == UpdateBootFlagsAction::StaticType()) {
591 SetStatusAndNotify(UpdateStatus::CLEANUP_PREVIOUS_UPDATE);
592 }
Alex Deymo5e3ea272016-01-28 13:42:23 -0800593 if (type == DownloadAction::StaticType()) {
Kelvin Zhangd2da7b12020-07-07 17:19:21 -0400594 auto download_action = static_cast<DownloadAction*>(action);
595 install_plan_ = *download_action->install_plan();
Kelvin Zhang70eef232020-06-12 20:32:40 +0000596 SetStatusAndNotify(UpdateStatus::VERIFYING);
Sen Jiang3eeaf7d2018-10-11 13:55:32 -0700597 } else if (type == FilesystemVerifierAction::StaticType()) {
Kelvin Zhang70eef232020-06-12 20:32:40 +0000598 SetStatusAndNotify(UpdateStatus::FINALIZING);
Sen Jiang3eeaf7d2018-10-11 13:55:32 -0700599 prefs_->SetBoolean(kPrefsVerityWritten, true);
Alex Deymo5e3ea272016-01-28 13:42:23 -0800600 }
601}
602
603void UpdateAttempterAndroid::BytesReceived(uint64_t bytes_progressed,
604 uint64_t bytes_received,
605 uint64_t total) {
Alex Deymo0d298542016-03-30 18:31:49 -0700606 double progress = 0;
Alex Deymo5e3ea272016-01-28 13:42:23 -0800607 if (total)
608 progress = static_cast<double>(bytes_received) / static_cast<double>(total);
Alex Deymo0d298542016-03-30 18:31:49 -0700609 if (status_ != UpdateStatus::DOWNLOADING || bytes_received == total) {
Alex Deymo5e3ea272016-01-28 13:42:23 -0800610 download_progress_ = progress;
611 SetStatusAndNotify(UpdateStatus::DOWNLOADING);
Alex Deymo0d298542016-03-30 18:31:49 -0700612 } else {
613 ProgressUpdate(progress);
Alex Deymo5e3ea272016-01-28 13:42:23 -0800614 }
Tianjie Xud4777a12017-10-24 14:54:18 -0700615
616 // Update the bytes downloaded in prefs.
617 int64_t current_bytes_downloaded =
618 metrics_utils::GetPersistedValue(kPrefsCurrentBytesDownloaded, prefs_);
619 int64_t total_bytes_downloaded =
620 metrics_utils::GetPersistedValue(kPrefsTotalBytesDownloaded, prefs_);
621 prefs_->SetInt64(kPrefsCurrentBytesDownloaded,
622 current_bytes_downloaded + bytes_progressed);
623 prefs_->SetInt64(kPrefsTotalBytesDownloaded,
624 total_bytes_downloaded + bytes_progressed);
Alex Deymo5e3ea272016-01-28 13:42:23 -0800625}
626
627bool UpdateAttempterAndroid::ShouldCancel(ErrorCode* cancel_reason) {
628 // TODO(deymo): Notify the DownloadAction that it should cancel the update
629 // download.
630 return false;
631}
632
633void UpdateAttempterAndroid::DownloadComplete() {
634 // Nothing needs to be done when the download completes.
635}
636
Alex Deymo0d298542016-03-30 18:31:49 -0700637void UpdateAttempterAndroid::ProgressUpdate(double progress) {
638 // Self throttle based on progress. Also send notifications if progress is
639 // too slow.
640 if (progress == 1.0 ||
641 progress - download_progress_ >= kBroadcastThresholdProgress ||
642 TimeTicks::Now() - last_notify_time_ >=
643 TimeDelta::FromSeconds(kBroadcastThresholdSeconds)) {
644 download_progress_ = progress;
645 SetStatusAndNotify(status_);
646 }
647}
648
Kelvin Zhang70eef232020-06-12 20:32:40 +0000649void UpdateAttempterAndroid::OnVerifyProgressUpdate(double progress) {
650 assert(status_ == UpdateStatus::VERIFYING);
651 ProgressUpdate(progress);
652}
653
Alex Deymo5e3ea272016-01-28 13:42:23 -0800654void UpdateAttempterAndroid::ScheduleProcessingStart() {
655 LOG(INFO) << "Scheduling an action processor start.";
656 brillo::MessageLoop::current()->PostTask(
Luis Hector Chavezf1cf3482016-07-19 14:29:19 -0700657 FROM_HERE,
658 Bind([](ActionProcessor* processor) { processor->StartProcessing(); },
659 base::Unretained(processor_.get())));
Alex Deymo5e3ea272016-01-28 13:42:23 -0800660}
661
662void UpdateAttempterAndroid::TerminateUpdateAndNotify(ErrorCode error_code) {
663 if (status_ == UpdateStatus::IDLE) {
664 LOG(ERROR) << "No ongoing update, but TerminatedUpdate() called.";
665 return;
666 }
667
Yifan Hong90965502020-02-19 15:22:47 -0800668 if (status_ == UpdateStatus::CLEANUP_PREVIOUS_UPDATE) {
669 LOG(INFO) << "Terminating cleanup previous update.";
670 SetStatusAndNotify(UpdateStatus::IDLE);
Yifan Hong5cd63fa2020-03-16 12:31:16 -0700671 for (auto observer : daemon_state_->service_observers())
672 observer->SendPayloadApplicationComplete(error_code);
Yifan Hong90965502020-02-19 15:22:47 -0800673 return;
674 }
675
Yifan Hong9194ce82019-11-07 11:03:42 -0800676 boot_control_->GetDynamicPartitionControl()->Cleanup();
Yifan Hong537802d2018-08-15 13:15:42 -0700677
Alex Deymo0d298542016-03-30 18:31:49 -0700678 download_progress_ = 0;
Alex Deymo5e3ea272016-01-28 13:42:23 -0800679 UpdateStatus new_status =
680 (error_code == ErrorCode::kSuccess ? UpdateStatus::UPDATED_NEED_REBOOT
681 : UpdateStatus::IDLE);
682 SetStatusAndNotify(new_status);
Kyeongkab.Nam500ca132019-06-26 13:48:07 +0900683 payload_fd_.reset();
Alex Deymo5e3ea272016-01-28 13:42:23 -0800684
Sen Jiangb19c3ec2017-10-06 15:18:46 -0700685 // The network id is only applicable to one download attempt and once it's
686 // done the network id should not be re-used anymore.
687 if (!network_selector_->SetProcessNetwork(kDefaultNetworkId)) {
688 LOG(WARNING) << "Unable to unbind network.";
689 }
690
Alex Deymo5e3ea272016-01-28 13:42:23 -0800691 for (auto observer : daemon_state_->service_observers())
692 observer->SendPayloadApplicationComplete(error_code);
Tianjie Xu1b661142017-09-28 14:03:42 -0700693
Tianjie Xu90aaa102017-10-10 17:39:03 -0700694 CollectAndReportUpdateMetricsOnUpdateFinished(error_code);
695 ClearMetricsPrefs();
696 if (error_code == ErrorCode::kSuccess) {
xunchang9cf52622019-01-25 11:04:58 -0800697 // We should only reset the PayloadAttemptNumber if the update succeeds, or
698 // we switch to a different payload.
699 prefs_->Delete(kPrefsPayloadAttemptNumber);
Tianjie Xu90aaa102017-10-10 17:39:03 -0700700 metrics_utils::SetSystemUpdatedMarker(clock_.get(), prefs_);
Tianjie Xud4777a12017-10-24 14:54:18 -0700701 // Clear the total bytes downloaded if and only if the update succeeds.
702 prefs_->SetInt64(kPrefsTotalBytesDownloaded, 0);
Tianjie Xu90aaa102017-10-10 17:39:03 -0700703 }
Alex Deymo5e3ea272016-01-28 13:42:23 -0800704}
705
706void UpdateAttempterAndroid::SetStatusAndNotify(UpdateStatus status) {
707 status_ = status;
Sen Jiang2d1c87b2017-07-14 10:46:14 -0700708 size_t payload_size =
709 install_plan_.payloads.empty() ? 0 : install_plan_.payloads[0].size;
Aaron Wood7f92e2b2017-08-28 14:51:21 -0700710 UpdateEngineStatus status_to_send = {.status = status_,
711 .progress = download_progress_,
712 .new_size_bytes = payload_size};
713
Alex Deymo5e3ea272016-01-28 13:42:23 -0800714 for (auto observer : daemon_state_->service_observers()) {
Aaron Wood7f92e2b2017-08-28 14:51:21 -0700715 observer->SendStatusUpdate(status_to_send);
Alex Deymo5e3ea272016-01-28 13:42:23 -0800716 }
717 last_notify_time_ = TimeTicks::Now();
718}
719
Amin Hassani667cf7b2018-07-25 14:32:00 -0700720void UpdateAttempterAndroid::BuildUpdateActions(HttpFetcher* fetcher) {
Alex Deymo5e3ea272016-01-28 13:42:23 -0800721 CHECK(!processor_->IsRunning());
722 processor_->set_delegate(this);
723
724 // Actions:
Amin Hassani667cf7b2018-07-25 14:32:00 -0700725 auto update_boot_flags_action =
726 std::make_unique<UpdateBootFlagsAction>(boot_control_);
Yifan Hong83517502020-02-19 15:34:13 -0800727 auto cleanup_previous_update_action =
728 boot_control_->GetDynamicPartitionControl()
729 ->GetCleanupPreviousUpdateAction(boot_control_, prefs_, this);
Amin Hassani667cf7b2018-07-25 14:32:00 -0700730 auto install_plan_action = std::make_unique<InstallPlanAction>(install_plan_);
731 auto download_action =
732 std::make_unique<DownloadAction>(prefs_,
733 boot_control_,
734 hardware_,
Amin Hassani667cf7b2018-07-25 14:32:00 -0700735 fetcher, // passes ownership
736 true /* interactive */);
Alex Deymo5e3ea272016-01-28 13:42:23 -0800737 download_action->set_delegate(this);
Sen Jiang5ae865b2017-04-18 14:24:40 -0700738 download_action->set_base_offset(base_offset_);
Tianjie24f96092020-06-30 12:26:25 -0700739 auto filesystem_verifier_action = std::make_unique<FilesystemVerifierAction>(
740 boot_control_->GetDynamicPartitionControl());
Amin Hassani667cf7b2018-07-25 14:32:00 -0700741 auto postinstall_runner_action =
742 std::make_unique<PostinstallRunnerAction>(boot_control_, hardware_);
Kelvin Zhang70eef232020-06-12 20:32:40 +0000743 filesystem_verifier_action->set_delegate(this);
Alex Deymob6eef732016-06-10 12:58:11 -0700744 postinstall_runner_action->set_delegate(this);
Alex Deymo5e3ea272016-01-28 13:42:23 -0800745
Alex Deymo5e3ea272016-01-28 13:42:23 -0800746 // Bond them together. We have to use the leaf-types when calling
747 // BondActions().
748 BondActions(install_plan_action.get(), download_action.get());
Sen Jiangfef85fd2016-03-25 15:32:49 -0700749 BondActions(download_action.get(), filesystem_verifier_action.get());
750 BondActions(filesystem_verifier_action.get(),
Alex Deymo5e3ea272016-01-28 13:42:23 -0800751 postinstall_runner_action.get());
752
Amin Hassani667cf7b2018-07-25 14:32:00 -0700753 processor_->EnqueueAction(std::move(update_boot_flags_action));
Yifan Hong83517502020-02-19 15:34:13 -0800754 processor_->EnqueueAction(std::move(cleanup_previous_update_action));
Amin Hassani667cf7b2018-07-25 14:32:00 -0700755 processor_->EnqueueAction(std::move(install_plan_action));
756 processor_->EnqueueAction(std::move(download_action));
757 processor_->EnqueueAction(std::move(filesystem_verifier_action));
758 processor_->EnqueueAction(std::move(postinstall_runner_action));
Alex Deymo5e3ea272016-01-28 13:42:23 -0800759}
760
Alex Deymo5e3ea272016-01-28 13:42:23 -0800761bool UpdateAttempterAndroid::WriteUpdateCompletedMarker() {
762 string boot_id;
763 TEST_AND_RETURN_FALSE(utils::GetBootId(&boot_id));
764 prefs_->SetString(kPrefsUpdateCompletedOnBootId, boot_id);
765 return true;
766}
767
768bool UpdateAttempterAndroid::UpdateCompletedOnThisBoot() {
769 // In case of an update_engine restart without a reboot, we stored the boot_id
770 // when the update was completed by setting a pref, so we can check whether
771 // the last update was on this boot or a previous one.
772 string boot_id;
773 TEST_AND_RETURN_FALSE(utils::GetBootId(&boot_id));
774
775 string update_completed_on_boot_id;
776 return (prefs_->Exists(kPrefsUpdateCompletedOnBootId) &&
777 prefs_->GetString(kPrefsUpdateCompletedOnBootId,
778 &update_completed_on_boot_id) &&
779 update_completed_on_boot_id == boot_id);
780}
781
Tianjie Xu90aaa102017-10-10 17:39:03 -0700782// Collect and report the android metrics when we terminate the update.
783void UpdateAttempterAndroid::CollectAndReportUpdateMetricsOnUpdateFinished(
784 ErrorCode error_code) {
785 int64_t attempt_number =
786 metrics_utils::GetPersistedValue(kPrefsPayloadAttemptNumber, prefs_);
787 PayloadType payload_type = kPayloadTypeFull;
788 int64_t payload_size = 0;
789 for (const auto& p : install_plan_.payloads) {
790 if (p.type == InstallPayloadType::kDelta)
791 payload_type = kPayloadTypeDelta;
792 payload_size += p.size;
793 }
794
795 metrics::AttemptResult attempt_result =
796 metrics_utils::GetAttemptResult(error_code);
Tianjie Xu2a0ea632018-08-06 12:59:23 -0700797 Time boot_time_start = Time::FromInternalValue(
798 metrics_utils::GetPersistedValue(kPrefsUpdateBootTimestampStart, prefs_));
799 Time monotonic_time_start = Time::FromInternalValue(
Tianjie Xu90aaa102017-10-10 17:39:03 -0700800 metrics_utils::GetPersistedValue(kPrefsUpdateTimestampStart, prefs_));
Tianjie Xu2a0ea632018-08-06 12:59:23 -0700801 TimeDelta duration = clock_->GetBootTime() - boot_time_start;
802 TimeDelta duration_uptime = clock_->GetMonotonicTime() - monotonic_time_start;
Tianjie Xu90aaa102017-10-10 17:39:03 -0700803
804 metrics_reporter_->ReportUpdateAttemptMetrics(
Tianjie Xu90aaa102017-10-10 17:39:03 -0700805 static_cast<int>(attempt_number),
806 payload_type,
Tianjie Xu52c678c2017-10-18 15:52:27 -0700807 duration,
Tianjie Xu90aaa102017-10-10 17:39:03 -0700808 duration_uptime,
809 payload_size,
810 attempt_result,
811 error_code);
812
Tianjie Xud4777a12017-10-24 14:54:18 -0700813 int64_t current_bytes_downloaded =
814 metrics_utils::GetPersistedValue(kPrefsCurrentBytesDownloaded, prefs_);
815 metrics_reporter_->ReportUpdateAttemptDownloadMetrics(
816 current_bytes_downloaded,
817 0,
818 DownloadSource::kNumDownloadSources,
819 metrics::DownloadErrorCode::kUnset,
820 metrics::ConnectionType::kUnset);
821
Tianjie Xu90aaa102017-10-10 17:39:03 -0700822 if (error_code == ErrorCode::kSuccess) {
823 int64_t reboot_count =
824 metrics_utils::GetPersistedValue(kPrefsNumReboots, prefs_);
825 string build_version;
826 prefs_->GetString(kPrefsPreviousVersion, &build_version);
Tianjie Xud4777a12017-10-24 14:54:18 -0700827
828 // For android metrics, we only care about the total bytes downloaded
829 // for all sources; for now we assume the only download source is
830 // HttpsServer.
831 int64_t total_bytes_downloaded =
832 metrics_utils::GetPersistedValue(kPrefsTotalBytesDownloaded, prefs_);
833 int64_t num_bytes_downloaded[kNumDownloadSources] = {};
834 num_bytes_downloaded[DownloadSource::kDownloadSourceHttpsServer] =
835 total_bytes_downloaded;
836
837 int download_overhead_percentage = 0;
Tianjie Xu21030c12019-08-14 13:00:23 -0700838 if (total_bytes_downloaded >= payload_size) {
839 CHECK_GT(payload_size, 0);
Tianjie Xud4777a12017-10-24 14:54:18 -0700840 download_overhead_percentage =
Tianjie Xu21030c12019-08-14 13:00:23 -0700841 (total_bytes_downloaded - payload_size) * 100ull / payload_size;
842 } else {
843 LOG(WARNING) << "Downloaded bytes " << total_bytes_downloaded
844 << " is smaller than the payload size " << payload_size;
Tianjie Xud4777a12017-10-24 14:54:18 -0700845 }
Tianjie Xu21030c12019-08-14 13:00:23 -0700846
Tianjie Xu90aaa102017-10-10 17:39:03 -0700847 metrics_reporter_->ReportSuccessfulUpdateMetrics(
848 static_cast<int>(attempt_number),
849 0, // update abandoned count
850 payload_type,
851 payload_size,
Tianjie Xud4777a12017-10-24 14:54:18 -0700852 num_bytes_downloaded,
853 download_overhead_percentage,
Tianjie Xu52c678c2017-10-18 15:52:27 -0700854 duration,
Sen Jiang8712e962018-05-08 12:12:28 -0700855 duration_uptime,
Tianjie Xu90aaa102017-10-10 17:39:03 -0700856 static_cast<int>(reboot_count),
857 0); // url_switch_count
858 }
859}
860
861void UpdateAttempterAndroid::UpdatePrefsAndReportUpdateMetricsOnReboot() {
862 string current_boot_id;
863 TEST_AND_RETURN(utils::GetBootId(&current_boot_id));
864 // Example: [ro.build.version.incremental]: [4292972]
865 string current_version =
866 android::base::GetProperty("ro.build.version.incremental", "");
867 TEST_AND_RETURN(!current_version.empty());
868
869 // If there's no record of previous version (e.g. due to a data wipe), we
870 // save the info of current boot and skip the metrics report.
871 if (!prefs_->Exists(kPrefsPreviousVersion)) {
872 prefs_->SetString(kPrefsBootId, current_boot_id);
873 prefs_->SetString(kPrefsPreviousVersion, current_version);
874 ClearMetricsPrefs();
875 return;
876 }
877 string previous_version;
878 // update_engine restarted under the same build.
879 // TODO(xunchang) identify and report rollback by checking UpdateMarker.
880 if (prefs_->GetString(kPrefsPreviousVersion, &previous_version) &&
881 previous_version == current_version) {
882 string last_boot_id;
883 bool is_reboot = prefs_->Exists(kPrefsBootId) &&
884 (prefs_->GetString(kPrefsBootId, &last_boot_id) &&
885 last_boot_id != current_boot_id);
886 // Increment the reboot number if |kPrefsNumReboots| exists. That pref is
887 // set when we start a new update.
888 if (is_reboot && prefs_->Exists(kPrefsNumReboots)) {
889 prefs_->SetString(kPrefsBootId, current_boot_id);
890 int64_t reboot_count =
891 metrics_utils::GetPersistedValue(kPrefsNumReboots, prefs_);
892 metrics_utils::SetNumReboots(reboot_count + 1, prefs_);
893 }
894 return;
895 }
896
897 // Now that the build version changes, report the update metrics.
898 // TODO(xunchang) check the build version is larger than the previous one.
899 prefs_->SetString(kPrefsBootId, current_boot_id);
900 prefs_->SetString(kPrefsPreviousVersion, current_version);
901
902 bool previous_attempt_exists = prefs_->Exists(kPrefsPayloadAttemptNumber);
903 // |kPrefsPayloadAttemptNumber| should be cleared upon successful update.
904 if (previous_attempt_exists) {
905 metrics_reporter_->ReportAbnormallyTerminatedUpdateAttemptMetrics();
906 }
907
908 metrics_utils::LoadAndReportTimeToReboot(
909 metrics_reporter_.get(), prefs_, clock_.get());
910 ClearMetricsPrefs();
Sen Jiang1bafff82019-01-02 15:54:40 -0800911
912 // Also reset the update progress if the build version has changed.
913 if (!DeltaPerformer::ResetUpdateProgress(prefs_, false)) {
914 LOG(WARNING) << "Unable to reset the update progress.";
915 }
Tianjie Xu90aaa102017-10-10 17:39:03 -0700916}
917
918// Save the update start time. Reset the reboot count and attempt number if the
919// update isn't a resume; otherwise increment the attempt number.
920void UpdateAttempterAndroid::UpdatePrefsOnUpdateStart(bool is_resume) {
921 if (!is_resume) {
922 metrics_utils::SetNumReboots(0, prefs_);
923 metrics_utils::SetPayloadAttemptNumber(1, prefs_);
924 } else {
925 int64_t attempt_number =
926 metrics_utils::GetPersistedValue(kPrefsPayloadAttemptNumber, prefs_);
927 metrics_utils::SetPayloadAttemptNumber(attempt_number + 1, prefs_);
928 }
Tianjie Xu2a0ea632018-08-06 12:59:23 -0700929 metrics_utils::SetUpdateTimestampStart(clock_->GetMonotonicTime(), prefs_);
930 metrics_utils::SetUpdateBootTimestampStart(clock_->GetBootTime(), prefs_);
Tianjie Xu90aaa102017-10-10 17:39:03 -0700931}
932
933void UpdateAttempterAndroid::ClearMetricsPrefs() {
934 CHECK(prefs_);
Tianjie Xud4777a12017-10-24 14:54:18 -0700935 prefs_->Delete(kPrefsCurrentBytesDownloaded);
Tianjie Xu90aaa102017-10-10 17:39:03 -0700936 prefs_->Delete(kPrefsNumReboots);
Tianjie Xu90aaa102017-10-10 17:39:03 -0700937 prefs_->Delete(kPrefsSystemUpdatedMarker);
938 prefs_->Delete(kPrefsUpdateTimestampStart);
Tianjie Xu2a0ea632018-08-06 12:59:23 -0700939 prefs_->Delete(kPrefsUpdateBootTimestampStart);
Tianjie Xu90aaa102017-10-10 17:39:03 -0700940}
941
Yifan Hongbd47d622019-12-13 14:59:58 -0800942BootControlInterface::Slot UpdateAttempterAndroid::GetCurrentSlot() const {
943 return boot_control_->GetCurrentSlot();
944}
945
946BootControlInterface::Slot UpdateAttempterAndroid::GetTargetSlot() const {
947 return GetCurrentSlot() == 0 ? 1 : 0;
948}
949
Yifan Hong6f7e29f2019-12-13 14:41:06 -0800950uint64_t UpdateAttempterAndroid::AllocateSpaceForPayload(
951 const std::string& metadata_filename,
952 const vector<string>& key_value_pair_headers,
953 brillo::ErrorPtr* error) {
Yifan Hong65613032020-01-09 17:52:13 -0800954 DeltaArchiveManifest manifest;
955 if (!VerifyPayloadParseManifest(metadata_filename, &manifest, error)) {
956 return 0;
957 }
958 std::map<string, string> headers;
959 if (!ParseKeyValuePairHeaders(key_value_pair_headers, &headers, error)) {
960 return 0;
961 }
962
963 string payload_id = GetPayloadId(headers);
964 uint64_t required_size = 0;
965 if (!DeltaPerformer::PreparePartitionsForUpdate(prefs_,
966 boot_control_,
967 GetTargetSlot(),
968 manifest,
969 payload_id,
970 &required_size)) {
971 if (required_size == 0) {
972 LogAndSetError(error, FROM_HERE, "Failed to allocate space for payload.");
973 return 0;
974 } else {
975 LOG(ERROR) << "Insufficient space for payload: " << required_size
976 << " bytes";
977 return required_size;
978 }
979 }
980
981 LOG(INFO) << "Successfully allocated space for payload.";
Yifan Hong6f7e29f2019-12-13 14:41:06 -0800982 return 0;
983}
984
Yifan Hong40bb0d02020-02-24 17:33:14 -0800985void UpdateAttempterAndroid::CleanupSuccessfulUpdate(
986 std::unique_ptr<CleanupSuccessfulUpdateCallbackInterface> callback,
Yifan Hong2236ea02019-12-13 16:11:22 -0800987 brillo::ErrorPtr* error) {
Yifan Hong40bb0d02020-02-24 17:33:14 -0800988 if (cleanup_previous_update_code_.has_value()) {
989 LOG(INFO) << "CleanupSuccessfulUpdate has previously completed with "
990 << utils::ErrorCodeToString(*cleanup_previous_update_code_);
991 if (callback) {
992 callback->OnCleanupComplete(
993 static_cast<int32_t>(*cleanup_previous_update_code_));
994 }
995 return;
Yifan Hong4f611562020-01-15 23:41:33 -0800996 }
Yifan Hong40bb0d02020-02-24 17:33:14 -0800997 if (callback) {
998 auto callback_ptr = callback.get();
999 cleanup_previous_update_callbacks_.emplace_back(std::move(callback));
1000 callback_ptr->RegisterForDeathNotifications(
1001 base::Bind(&UpdateAttempterAndroid::RemoveCleanupPreviousUpdateCallback,
1002 base::Unretained(this),
1003 base::Unretained(callback_ptr)));
1004 }
1005 ScheduleCleanupPreviousUpdate();
Yifan Hong2236ea02019-12-13 16:11:22 -08001006}
1007
Yifan Hong90965502020-02-19 15:22:47 -08001008void UpdateAttempterAndroid::ScheduleCleanupPreviousUpdate() {
1009 // If a previous CleanupSuccessfulUpdate call has not finished, or an update
1010 // is in progress, skip enqueueing the action.
1011 if (processor_->IsRunning()) {
1012 LOG(INFO) << "Already processing an update. CleanupPreviousUpdate should "
1013 << "be done when the current update finishes.";
1014 return;
1015 }
1016 LOG(INFO) << "Scheduling CleanupPreviousUpdateAction.";
1017 auto action =
1018 boot_control_->GetDynamicPartitionControl()
1019 ->GetCleanupPreviousUpdateAction(boot_control_, prefs_, this);
1020 processor_->EnqueueAction(std::move(action));
1021 processor_->set_delegate(this);
1022 SetStatusAndNotify(UpdateStatus::CLEANUP_PREVIOUS_UPDATE);
1023 processor_->StartProcessing();
1024}
1025
Yifan Hong40bb0d02020-02-24 17:33:14 -08001026void UpdateAttempterAndroid::OnCleanupProgressUpdate(double progress) {
1027 for (auto&& callback : cleanup_previous_update_callbacks_) {
1028 callback->OnCleanupProgressUpdate(progress);
1029 }
1030}
1031
1032void UpdateAttempterAndroid::NotifyCleanupPreviousUpdateCallbacksAndClear() {
1033 CHECK(cleanup_previous_update_code_.has_value());
1034 for (auto&& callback : cleanup_previous_update_callbacks_) {
1035 callback->OnCleanupComplete(
1036 static_cast<int32_t>(*cleanup_previous_update_code_));
1037 }
1038 cleanup_previous_update_callbacks_.clear();
1039}
1040
1041void UpdateAttempterAndroid::RemoveCleanupPreviousUpdateCallback(
1042 CleanupSuccessfulUpdateCallbackInterface* callback) {
1043 auto end_it =
1044 std::remove_if(cleanup_previous_update_callbacks_.begin(),
1045 cleanup_previous_update_callbacks_.end(),
1046 [&](const auto& e) { return e.get() == callback; });
1047 cleanup_previous_update_callbacks_.erase(
1048 end_it, cleanup_previous_update_callbacks_.end());
1049}
Yifan Hong90965502020-02-19 15:22:47 -08001050
Alex Deymo5e3ea272016-01-28 13:42:23 -08001051} // namespace chromeos_update_engine