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