1 //
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
17 #include "update_engine/update_attempter_android.h"
18
19 #include <algorithm>
20 #include <map>
21 #include <utility>
22
23 #include <base/bind.h>
24 #include <base/logging.h>
25 #include <base/strings/string_number_conversions.h>
26 #include <brillo/bind_lambda.h>
27 #include <brillo/message_loops/message_loop.h>
28 #include <brillo/strings/string_utils.h>
29
30 #include "update_engine/common/constants.h"
31 #include "update_engine/common/libcurl_http_fetcher.h"
32 #include "update_engine/common/multi_range_http_fetcher.h"
33 #include "update_engine/common/utils.h"
34 #include "update_engine/daemon_state_android.h"
35 #include "update_engine/payload_consumer/download_action.h"
36 #include "update_engine/payload_consumer/filesystem_verifier_action.h"
37 #include "update_engine/payload_consumer/postinstall_runner_action.h"
38 #include "update_engine/update_status_utils.h"
39
40 using base::Bind;
41 using base::TimeDelta;
42 using base::TimeTicks;
43 using std::shared_ptr;
44 using std::string;
45 using std::vector;
46
47 namespace chromeos_update_engine {
48
49 namespace {
50
51 // Minimum threshold to broadcast an status update in progress and time.
52 const double kBroadcastThresholdProgress = 0.01; // 1%
53 const int kBroadcastThresholdSeconds = 10;
54
55 const char* const kErrorDomain = "update_engine";
56 // TODO(deymo): Convert the different errors to a numeric value to report them
57 // back on the service error.
58 const char* const kGenericError = "generic_error";
59
60 // Log and set the error on the passed ErrorPtr.
LogAndSetError(brillo::ErrorPtr * error,const tracked_objects::Location & location,const string & reason)61 bool LogAndSetError(brillo::ErrorPtr* error,
62 const tracked_objects::Location& location,
63 const string& reason) {
64 brillo::Error::AddTo(error, location, kErrorDomain, kGenericError, reason);
65 LOG(ERROR) << "Replying with failure: " << location.ToString() << ": "
66 << reason;
67 return false;
68 }
69
70 } // namespace
71
UpdateAttempterAndroid(DaemonStateAndroid * daemon_state,PrefsInterface * prefs,BootControlInterface * boot_control,HardwareInterface * hardware)72 UpdateAttempterAndroid::UpdateAttempterAndroid(
73 DaemonStateAndroid* daemon_state,
74 PrefsInterface* prefs,
75 BootControlInterface* boot_control,
76 HardwareInterface* hardware)
77 : daemon_state_(daemon_state),
78 prefs_(prefs),
79 boot_control_(boot_control),
80 hardware_(hardware),
81 processor_(new ActionProcessor()) {
82 }
83
~UpdateAttempterAndroid()84 UpdateAttempterAndroid::~UpdateAttempterAndroid() {
85 // Release ourselves as the ActionProcessor's delegate to prevent
86 // re-scheduling the updates due to the processing stopped.
87 processor_->set_delegate(nullptr);
88 }
89
Init()90 void UpdateAttempterAndroid::Init() {
91 // In case of update_engine restart without a reboot we need to restore the
92 // reboot needed state.
93 if (UpdateCompletedOnThisBoot())
94 SetStatusAndNotify(UpdateStatus::UPDATED_NEED_REBOOT);
95 else
96 SetStatusAndNotify(UpdateStatus::IDLE);
97 }
98
ApplyPayload(const string & payload_url,int64_t payload_offset,int64_t payload_size,const vector<string> & key_value_pair_headers,brillo::ErrorPtr * error)99 bool UpdateAttempterAndroid::ApplyPayload(
100 const string& payload_url,
101 int64_t payload_offset,
102 int64_t payload_size,
103 const vector<string>& key_value_pair_headers,
104 brillo::ErrorPtr* error) {
105 if (status_ == UpdateStatus::UPDATED_NEED_REBOOT) {
106 return LogAndSetError(
107 error, FROM_HERE, "An update already applied, waiting for reboot");
108 }
109 if (ongoing_update_) {
110 return LogAndSetError(
111 error, FROM_HERE, "Already processing an update, cancel it first.");
112 }
113 DCHECK(status_ == UpdateStatus::IDLE);
114
115 std::map<string, string> headers;
116 for (const string& key_value_pair : key_value_pair_headers) {
117 string key;
118 string value;
119 if (!brillo::string_utils::SplitAtFirst(
120 key_value_pair, "=", &key, &value, false)) {
121 return LogAndSetError(
122 error, FROM_HERE, "Passed invalid header: " + key_value_pair);
123 }
124 if (!headers.emplace(key, value).second)
125 return LogAndSetError(error, FROM_HERE, "Passed repeated key: " + key);
126 }
127
128 // Unique identifier for the payload. An empty string means that the payload
129 // can't be resumed.
130 string payload_id = (headers[kPayloadPropertyFileHash] +
131 headers[kPayloadPropertyMetadataHash]);
132
133 // Setup the InstallPlan based on the request.
134 install_plan_ = InstallPlan();
135
136 install_plan_.download_url = payload_url;
137 install_plan_.version = "";
138 base_offset_ = payload_offset;
139 install_plan_.payload_size = payload_size;
140 if (!install_plan_.payload_size) {
141 if (!base::StringToUint64(headers[kPayloadPropertyFileSize],
142 &install_plan_.payload_size)) {
143 install_plan_.payload_size = 0;
144 }
145 }
146 install_plan_.payload_hash = headers[kPayloadPropertyFileHash];
147 if (!base::StringToUint64(headers[kPayloadPropertyMetadataSize],
148 &install_plan_.metadata_size)) {
149 install_plan_.metadata_size = 0;
150 }
151 install_plan_.metadata_signature = "";
152 // The |public_key_rsa| key would override the public key stored on disk.
153 install_plan_.public_key_rsa = "";
154
155 install_plan_.hash_checks_mandatory = hardware_->IsOfficialBuild();
156 install_plan_.is_resume = !payload_id.empty() &&
157 DeltaPerformer::CanResumeUpdate(prefs_, payload_id);
158 if (!install_plan_.is_resume) {
159 if (!DeltaPerformer::ResetUpdateProgress(prefs_, false)) {
160 LOG(WARNING) << "Unable to reset the update progress.";
161 }
162 if (!prefs_->SetString(kPrefsUpdateCheckResponseHash, payload_id)) {
163 LOG(WARNING) << "Unable to save the update check response hash.";
164 }
165 }
166 // The |payload_type| is not used anymore since minor_version 3.
167 install_plan_.payload_type = InstallPayloadType::kUnknown;
168
169 install_plan_.source_slot = boot_control_->GetCurrentSlot();
170 install_plan_.target_slot = install_plan_.source_slot == 0 ? 1 : 0;
171 install_plan_.powerwash_required = false;
172
173 LOG(INFO) << "Using this install plan:";
174 install_plan_.Dump();
175
176 BuildUpdateActions();
177 SetupDownload();
178 // Setup extra headers.
179 HttpFetcher* fetcher = download_action_->http_fetcher();
180 if (!headers[kPayloadPropertyAuthorization].empty())
181 fetcher->SetHeader("Authorization", headers[kPayloadPropertyAuthorization]);
182 if (!headers[kPayloadPropertyUserAgent].empty())
183 fetcher->SetHeader("User-Agent", headers[kPayloadPropertyUserAgent]);
184
185 cpu_limiter_.StartLimiter();
186 SetStatusAndNotify(UpdateStatus::UPDATE_AVAILABLE);
187 ongoing_update_ = true;
188
189 // Just in case we didn't update boot flags yet, make sure they're updated
190 // before any update processing starts. This will start the update process.
191 UpdateBootFlags();
192 return true;
193 }
194
SuspendUpdate(brillo::ErrorPtr * error)195 bool UpdateAttempterAndroid::SuspendUpdate(brillo::ErrorPtr* error) {
196 if (!ongoing_update_)
197 return LogAndSetError(error, FROM_HERE, "No ongoing update to suspend.");
198 processor_->SuspendProcessing();
199 return true;
200 }
201
ResumeUpdate(brillo::ErrorPtr * error)202 bool UpdateAttempterAndroid::ResumeUpdate(brillo::ErrorPtr* error) {
203 if (!ongoing_update_)
204 return LogAndSetError(error, FROM_HERE, "No ongoing update to resume.");
205 processor_->ResumeProcessing();
206 return true;
207 }
208
CancelUpdate(brillo::ErrorPtr * error)209 bool UpdateAttempterAndroid::CancelUpdate(brillo::ErrorPtr* error) {
210 if (!ongoing_update_)
211 return LogAndSetError(error, FROM_HERE, "No ongoing update to cancel.");
212 processor_->StopProcessing();
213 return true;
214 }
215
ResetStatus(brillo::ErrorPtr * error)216 bool UpdateAttempterAndroid::ResetStatus(brillo::ErrorPtr* error) {
217 LOG(INFO) << "Attempting to reset state from "
218 << UpdateStatusToString(status_) << " to UpdateStatus::IDLE";
219
220 switch (status_) {
221 case UpdateStatus::IDLE:
222 return true;
223
224 case UpdateStatus::UPDATED_NEED_REBOOT: {
225 // Remove the reboot marker so that if the machine is rebooted
226 // after resetting to idle state, it doesn't go back to
227 // UpdateStatus::UPDATED_NEED_REBOOT state.
228 bool ret_value = prefs_->Delete(kPrefsUpdateCompletedOnBootId);
229
230 // Update the boot flags so the current slot has higher priority.
231 if (!boot_control_->SetActiveBootSlot(boot_control_->GetCurrentSlot()))
232 ret_value = false;
233
234 if (!ret_value) {
235 return LogAndSetError(
236 error,
237 FROM_HERE,
238 "Failed to reset the status to ");
239 }
240
241 SetStatusAndNotify(UpdateStatus::IDLE);
242 LOG(INFO) << "Reset status successful";
243 return true;
244 }
245
246 default:
247 return LogAndSetError(
248 error,
249 FROM_HERE,
250 "Reset not allowed in this state. Cancel the ongoing update first");
251 }
252 }
253
ProcessingDone(const ActionProcessor * processor,ErrorCode code)254 void UpdateAttempterAndroid::ProcessingDone(const ActionProcessor* processor,
255 ErrorCode code) {
256 LOG(INFO) << "Processing Done.";
257
258 if (code == ErrorCode::kSuccess) {
259 // Update succeeded.
260 WriteUpdateCompletedMarker();
261 prefs_->SetInt64(kPrefsDeltaUpdateFailures, 0);
262 DeltaPerformer::ResetUpdateProgress(prefs_, false);
263
264 LOG(INFO) << "Update successfully applied, waiting to reboot.";
265 }
266
267 TerminateUpdateAndNotify(code);
268 }
269
ProcessingStopped(const ActionProcessor * processor)270 void UpdateAttempterAndroid::ProcessingStopped(
271 const ActionProcessor* processor) {
272 TerminateUpdateAndNotify(ErrorCode::kUserCanceled);
273 }
274
ActionCompleted(ActionProcessor * processor,AbstractAction * action,ErrorCode code)275 void UpdateAttempterAndroid::ActionCompleted(ActionProcessor* processor,
276 AbstractAction* action,
277 ErrorCode code) {
278 // Reset download progress regardless of whether or not the download
279 // action succeeded.
280 const string type = action->Type();
281 if (type == DownloadAction::StaticType()) {
282 download_progress_ = 0;
283 }
284 if (code != ErrorCode::kSuccess) {
285 // If an action failed, the ActionProcessor will cancel the whole thing.
286 return;
287 }
288 if (type == DownloadAction::StaticType()) {
289 SetStatusAndNotify(UpdateStatus::FINALIZING);
290 }
291 }
292
BytesReceived(uint64_t bytes_progressed,uint64_t bytes_received,uint64_t total)293 void UpdateAttempterAndroid::BytesReceived(uint64_t bytes_progressed,
294 uint64_t bytes_received,
295 uint64_t total) {
296 double progress = 0;
297 if (total)
298 progress = static_cast<double>(bytes_received) / static_cast<double>(total);
299 if (status_ != UpdateStatus::DOWNLOADING || bytes_received == total) {
300 download_progress_ = progress;
301 SetStatusAndNotify(UpdateStatus::DOWNLOADING);
302 } else {
303 ProgressUpdate(progress);
304 }
305 }
306
ShouldCancel(ErrorCode * cancel_reason)307 bool UpdateAttempterAndroid::ShouldCancel(ErrorCode* cancel_reason) {
308 // TODO(deymo): Notify the DownloadAction that it should cancel the update
309 // download.
310 return false;
311 }
312
DownloadComplete()313 void UpdateAttempterAndroid::DownloadComplete() {
314 // Nothing needs to be done when the download completes.
315 }
316
ProgressUpdate(double progress)317 void UpdateAttempterAndroid::ProgressUpdate(double progress) {
318 // Self throttle based on progress. Also send notifications if progress is
319 // too slow.
320 if (progress == 1.0 ||
321 progress - download_progress_ >= kBroadcastThresholdProgress ||
322 TimeTicks::Now() - last_notify_time_ >=
323 TimeDelta::FromSeconds(kBroadcastThresholdSeconds)) {
324 download_progress_ = progress;
325 SetStatusAndNotify(status_);
326 }
327 }
328
UpdateBootFlags()329 void UpdateAttempterAndroid::UpdateBootFlags() {
330 if (updated_boot_flags_) {
331 LOG(INFO) << "Already updated boot flags. Skipping.";
332 CompleteUpdateBootFlags(true);
333 return;
334 }
335 // This is purely best effort.
336 LOG(INFO) << "Marking booted slot as good.";
337 if (!boot_control_->MarkBootSuccessfulAsync(
338 Bind(&UpdateAttempterAndroid::CompleteUpdateBootFlags,
339 base::Unretained(this)))) {
340 LOG(ERROR) << "Failed to mark current boot as successful.";
341 CompleteUpdateBootFlags(false);
342 }
343 }
344
CompleteUpdateBootFlags(bool successful)345 void UpdateAttempterAndroid::CompleteUpdateBootFlags(bool successful) {
346 updated_boot_flags_ = true;
347 ScheduleProcessingStart();
348 }
349
ScheduleProcessingStart()350 void UpdateAttempterAndroid::ScheduleProcessingStart() {
351 LOG(INFO) << "Scheduling an action processor start.";
352 brillo::MessageLoop::current()->PostTask(
353 FROM_HERE, Bind([this] { this->processor_->StartProcessing(); }));
354 }
355
TerminateUpdateAndNotify(ErrorCode error_code)356 void UpdateAttempterAndroid::TerminateUpdateAndNotify(ErrorCode error_code) {
357 if (status_ == UpdateStatus::IDLE) {
358 LOG(ERROR) << "No ongoing update, but TerminatedUpdate() called.";
359 return;
360 }
361
362 // Reset cpu shares back to normal.
363 cpu_limiter_.StopLimiter();
364 download_progress_ = 0;
365 actions_.clear();
366 UpdateStatus new_status =
367 (error_code == ErrorCode::kSuccess ? UpdateStatus::UPDATED_NEED_REBOOT
368 : UpdateStatus::IDLE);
369 SetStatusAndNotify(new_status);
370 ongoing_update_ = false;
371
372 for (auto observer : daemon_state_->service_observers())
373 observer->SendPayloadApplicationComplete(error_code);
374 }
375
SetStatusAndNotify(UpdateStatus status)376 void UpdateAttempterAndroid::SetStatusAndNotify(UpdateStatus status) {
377 status_ = status;
378 for (auto observer : daemon_state_->service_observers()) {
379 observer->SendStatusUpdate(
380 0, download_progress_, status_, "", install_plan_.payload_size);
381 }
382 last_notify_time_ = TimeTicks::Now();
383 }
384
BuildUpdateActions()385 void UpdateAttempterAndroid::BuildUpdateActions() {
386 CHECK(!processor_->IsRunning());
387 processor_->set_delegate(this);
388
389 // Actions:
390 shared_ptr<InstallPlanAction> install_plan_action(
391 new InstallPlanAction(install_plan_));
392
393 LibcurlHttpFetcher* download_fetcher =
394 new LibcurlHttpFetcher(&proxy_resolver_, hardware_);
395 download_fetcher->set_server_to_check(ServerToCheck::kDownload);
396 shared_ptr<DownloadAction> download_action(new DownloadAction(
397 prefs_,
398 boot_control_,
399 hardware_,
400 nullptr, // system_state, not used.
401 new MultiRangeHttpFetcher(download_fetcher))); // passes ownership
402 shared_ptr<FilesystemVerifierAction> dst_filesystem_verifier_action(
403 new FilesystemVerifierAction(boot_control_,
404 VerifierMode::kVerifyTargetHash));
405
406 shared_ptr<PostinstallRunnerAction> postinstall_runner_action(
407 new PostinstallRunnerAction(boot_control_));
408
409 download_action->set_delegate(this);
410 download_action_ = download_action;
411
412 actions_.push_back(shared_ptr<AbstractAction>(install_plan_action));
413 actions_.push_back(shared_ptr<AbstractAction>(download_action));
414 actions_.push_back(
415 shared_ptr<AbstractAction>(dst_filesystem_verifier_action));
416 actions_.push_back(shared_ptr<AbstractAction>(postinstall_runner_action));
417
418 // Bond them together. We have to use the leaf-types when calling
419 // BondActions().
420 BondActions(install_plan_action.get(), download_action.get());
421 BondActions(download_action.get(), dst_filesystem_verifier_action.get());
422 BondActions(dst_filesystem_verifier_action.get(),
423 postinstall_runner_action.get());
424
425 // Enqueue the actions.
426 for (const shared_ptr<AbstractAction>& action : actions_)
427 processor_->EnqueueAction(action.get());
428 }
429
SetupDownload()430 void UpdateAttempterAndroid::SetupDownload() {
431 MultiRangeHttpFetcher* fetcher =
432 static_cast<MultiRangeHttpFetcher*>(download_action_->http_fetcher());
433 fetcher->ClearRanges();
434 if (install_plan_.is_resume) {
435 // Resuming an update so fetch the update manifest metadata first.
436 int64_t manifest_metadata_size = 0;
437 int64_t manifest_signature_size = 0;
438 prefs_->GetInt64(kPrefsManifestMetadataSize, &manifest_metadata_size);
439 prefs_->GetInt64(kPrefsManifestSignatureSize, &manifest_signature_size);
440 fetcher->AddRange(base_offset_,
441 manifest_metadata_size + manifest_signature_size);
442 // If there're remaining unprocessed data blobs, fetch them. Be careful not
443 // to request data beyond the end of the payload to avoid 416 HTTP response
444 // error codes.
445 int64_t next_data_offset = 0;
446 prefs_->GetInt64(kPrefsUpdateStateNextDataOffset, &next_data_offset);
447 uint64_t resume_offset =
448 manifest_metadata_size + manifest_signature_size + next_data_offset;
449 if (!install_plan_.payload_size) {
450 fetcher->AddRange(base_offset_ + resume_offset);
451 } else if (resume_offset < install_plan_.payload_size) {
452 fetcher->AddRange(base_offset_ + resume_offset,
453 install_plan_.payload_size - resume_offset);
454 }
455 } else {
456 if (install_plan_.payload_size) {
457 fetcher->AddRange(base_offset_, install_plan_.payload_size);
458 } else {
459 // If no payload size is passed we assume we read until the end of the
460 // stream.
461 fetcher->AddRange(base_offset_);
462 }
463 }
464 }
465
WriteUpdateCompletedMarker()466 bool UpdateAttempterAndroid::WriteUpdateCompletedMarker() {
467 string boot_id;
468 TEST_AND_RETURN_FALSE(utils::GetBootId(&boot_id));
469 prefs_->SetString(kPrefsUpdateCompletedOnBootId, boot_id);
470 return true;
471 }
472
UpdateCompletedOnThisBoot()473 bool UpdateAttempterAndroid::UpdateCompletedOnThisBoot() {
474 // In case of an update_engine restart without a reboot, we stored the boot_id
475 // when the update was completed by setting a pref, so we can check whether
476 // the last update was on this boot or a previous one.
477 string boot_id;
478 TEST_AND_RETURN_FALSE(utils::GetBootId(&boot_id));
479
480 string update_completed_on_boot_id;
481 return (prefs_->Exists(kPrefsUpdateCompletedOnBootId) &&
482 prefs_->GetString(kPrefsUpdateCompletedOnBootId,
483 &update_completed_on_boot_id) &&
484 update_completed_on_boot_id == boot_id);
485 }
486
487 } // namespace chromeos_update_engine
488