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 #ifndef UPDATE_ENGINE_AOSP_UPDATE_ATTEMPTER_ANDROID_H_ 18 #define UPDATE_ENGINE_AOSP_UPDATE_ATTEMPTER_ANDROID_H_ 19 20 #include <stdint.h> 21 22 #include <memory> 23 #include <string> 24 #include <vector> 25 26 #include <android-base/unique_fd.h> 27 #include <base/time/time.h> 28 29 #include "update_engine/aosp/apex_handler_interface.h" 30 #include "update_engine/aosp/service_delegate_android_interface.h" 31 #include "update_engine/client_library/include/update_engine/update_status.h" 32 #include "update_engine/common/action_processor.h" 33 #include "update_engine/common/boot_control_interface.h" 34 #include "update_engine/common/clock_interface.h" 35 #include "update_engine/common/daemon_state_interface.h" 36 #include "update_engine/common/download_action.h" 37 #include "update_engine/common/error_code.h" 38 #include "update_engine/common/hardware_interface.h" 39 #include "update_engine/common/metrics_reporter_interface.h" 40 #include "update_engine/common/network_selector_interface.h" 41 #include "update_engine/common/prefs_interface.h" 42 #include "update_engine/metrics_utils.h" 43 #include "update_engine/payload_consumer/filesystem_verifier_action.h" 44 #include "update_engine/payload_consumer/postinstall_runner_action.h" 45 46 namespace chromeos_update_engine { 47 48 enum class OTAResult { 49 NOT_ATTEMPTED, 50 ROLLED_BACK, 51 UPDATED_NEED_REBOOT, 52 OTA_SUCCESSFUL, 53 }; 54 55 class UpdateAttempterAndroid final 56 : public ServiceDelegateAndroidInterface, 57 public ActionProcessorDelegate, 58 public DownloadActionDelegate, 59 public FilesystemVerifyDelegate, 60 public PostinstallRunnerAction::DelegateInterface, 61 public CleanupPreviousUpdateActionDelegateInterface { 62 public: 63 using UpdateStatus = update_engine::UpdateStatus; 64 65 UpdateAttempterAndroid(DaemonStateInterface* daemon_state, 66 PrefsInterface* prefs, 67 BootControlInterface* boot_control_, 68 HardwareInterface* hardware_, 69 std::unique_ptr<ApexHandlerInterface> apex_handler); 70 ~UpdateAttempterAndroid() override; 71 72 // Further initialization to be done post construction. 73 void Init(); 74 75 // ServiceDelegateAndroidInterface overrides. 76 bool ApplyPayload(const std::string& payload_url, 77 int64_t payload_offset, 78 int64_t payload_size, 79 const std::vector<std::string>& key_value_pair_headers, 80 Error* error) override; 81 bool ApplyPayload(int fd, 82 int64_t payload_offset, 83 int64_t payload_size, 84 const std::vector<std::string>& key_value_pair_headers, 85 Error* error) override; 86 bool SuspendUpdate(Error* error) override; 87 bool ResumeUpdate(Error* error) override; 88 bool CancelUpdate(Error* error) override; 89 bool ResetStatus(Error* error) override; 90 bool VerifyPayloadApplicable(const std::string& metadata_filename, 91 Error* error) override; 92 uint64_t AllocateSpaceForPayload( 93 const std::string& metadata_filename, 94 const std::vector<std::string>& key_value_pair_headers, 95 Error* error) override; 96 void CleanupSuccessfulUpdate( 97 std::unique_ptr<CleanupSuccessfulUpdateCallbackInterface> callback, 98 Error* error) override; 99 bool setShouldSwitchSlotOnReboot(const std::string& metadata_filename, 100 Error* error) override; 101 bool resetShouldSwitchSlotOnReboot(Error* error) override; 102 bool TriggerPostinstall(const std::string& partition, Error* error) override; 103 104 // ActionProcessorDelegate methods: 105 void ProcessingDone(const ActionProcessor* processor, 106 ErrorCode code) override; 107 void ProcessingStopped(const ActionProcessor* processor) override; 108 void ActionCompleted(ActionProcessor* processor, 109 AbstractAction* action, 110 ErrorCode code) override; 111 112 // DownloadActionDelegate overrides. 113 void BytesReceived(uint64_t bytes_progressed, 114 uint64_t bytes_received, 115 uint64_t total) override; 116 bool ShouldCancel(ErrorCode* cancel_reason) override; 117 void DownloadComplete() override; 118 119 // FilesystemVerifyDelegate overrides 120 void OnVerifyProgressUpdate(double progress) override; 121 122 // PostinstallRunnerAction::DelegateInterface 123 void ProgressUpdate(double progress) override; 124 125 // CleanupPreviousUpdateActionDelegateInterface 126 void OnCleanupProgressUpdate(double progress) override; 127 128 // Check the result of an OTA update. Intended to be called after reboot, this 129 // will use prefs on disk to determine if OTA was installed, or rolledback. 130 [[nodiscard]] OTAResult GetOTAUpdateResult() const; 131 // Intended to be called: 132 // 1. When system rebooted and slot switch is attempted 133 // 2. When a new update is started 134 // 3. When user called |ResetStatus()| 135 bool ClearUpdateCompletedMarker(); 136 set_update_certificates_path(const std::string & update_certificates_path)137 void set_update_certificates_path( 138 const std::string& update_certificates_path) { 139 update_certificates_path_ = update_certificates_path; 140 } 141 142 private: 143 friend class UpdateAttempterAndroidTest; 144 145 // Return |true| only if slot switched successfully after an OTA reboot. 146 // This will return |false| if an downgrade OTA is applied. Because after a 147 // downgrade OTA, we wipe /data, and there's no way for update_engine to 148 // "remember" that a downgrade OTA took place. 149 [[nodiscard]] bool OTARebootSucceeded() const; 150 151 // Schedules an event loop callback to start the action processor. This is 152 // scheduled asynchronously to unblock the event loop. 153 void ScheduleProcessingStart(); 154 155 // Notifies an update request completed with the given error |code| to all 156 // observers. 157 void TerminateUpdateAndNotify(ErrorCode error_code); 158 159 // Sets the status to the given |status| and notifies a status update to 160 // all observers. 161 void SetStatusAndNotify(UpdateStatus status); 162 163 // Helper method to construct the sequence of actions to be performed for 164 // applying an update using a given HttpFetcher. The ownership of |fetcher| is 165 // passed to this function. 166 void BuildUpdateActions(HttpFetcher* fetcher); 167 168 // Writes to the processing completed marker. Does nothing if 169 // |update_completed_marker_| is empty. 170 [[nodiscard]] bool WriteUpdateCompletedMarker(); 171 172 // Returns whether a slot switch was attempted in the current boot. 173 [[nodiscard]] bool UpdateCompletedOnThisBoot() const; 174 175 // Prefs to use for metrics report 176 // |kPrefsPayloadAttemptNumber|: number of update attempts for the current 177 // payload_id. 178 // |KprefsNumReboots|: number of reboots when applying the current update. 179 // |kPrefsSystemUpdatedMarker|: end timestamp of the last successful update. 180 // |kPrefsUpdateTimestampStart|: start timestamp in monotonic time of the 181 // current update. 182 // |kPrefsUpdateBootTimestampStart|: start timestamp in boot time of 183 // the current update. 184 // |kPrefsCurrentBytesDownloaded|: number of bytes downloaded for the current 185 // payload_id. 186 // |kPrefsTotalBytesDownloaded|: number of bytes downloaded in total since 187 // the last successful update. 188 189 // Metrics report function to call: 190 // |ReportUpdateAttemptMetrics| 191 // |ReportSuccessfulUpdateMetrics| 192 // Prefs to update: 193 // |kPrefsSystemUpdatedMarker| 194 void CollectAndReportUpdateMetricsOnUpdateFinished(ErrorCode error_code); 195 196 // This function is called after update_engine is started after device 197 // reboots. If update_engine is restarted w/o device reboot, this function 198 // would not be called. 199 200 // Metrics report function to call: 201 // |ReportAbnormallyTerminatedUpdateAttemptMetrics| 202 // |ReportTimeToRebootMetrics| 203 // Prefs to update: 204 // |kPrefsBootId|, |kPrefsPreviousVersion| 205 void UpdateStateAfterReboot(OTAResult result); 206 207 // Prefs to update: 208 // |kPrefsPayloadAttemptNumber|, |kPrefsUpdateTimestampStart|, 209 // |kPrefsUpdateBootTimestampStart| 210 void UpdatePrefsOnUpdateStart(bool is_resume); 211 212 // Prefs to delete: 213 // |kPrefsNumReboots|, |kPrefsCurrentBytesDownloaded| 214 // |kPrefsSystemUpdatedMarker|, |kPrefsUpdateTimestampStart|, 215 // |kPrefsUpdateBootTimestampStart| 216 void ClearMetricsPrefs(); 217 218 // Return source and target slots for update. 219 BootControlInterface::Slot GetCurrentSlot() const; 220 BootControlInterface::Slot GetTargetSlot() const; 221 222 // Helper of public VerifyPayloadApplicable. Return the parsed manifest in 223 // |manifest|. 224 static bool VerifyPayloadParseManifest(const std::string& metadata_filename, 225 std::string_view metadata_hash, 226 DeltaArchiveManifest* manifest, 227 Error* error); VerifyPayloadParseManifest(const std::string & metadata_filename,DeltaArchiveManifest * manifest,Error * error)228 static bool VerifyPayloadParseManifest(const std::string& metadata_filename, 229 DeltaArchiveManifest* manifest, 230 Error* error) { 231 return VerifyPayloadParseManifest(metadata_filename, "", manifest, error); 232 } 233 234 // Enqueue and run a CleanupPreviousUpdateAction. 235 void ScheduleCleanupPreviousUpdate(); 236 237 // Notify and clear |cleanup_previous_update_callbacks_|. 238 void NotifyCleanupPreviousUpdateCallbacksAndClear(); 239 240 // Remove |callback| from |cleanup_previous_update_callbacks_|. 241 void RemoveCleanupPreviousUpdateCallback( 242 CleanupSuccessfulUpdateCallbackInterface* callback); 243 244 bool IsProductionBuild(); 245 246 DaemonStateInterface* daemon_state_; 247 248 // DaemonStateAndroid pointers. 249 PrefsInterface* prefs_; 250 BootControlInterface* boot_control_; 251 HardwareInterface* hardware_; 252 253 std::unique_ptr<ApexHandlerInterface> apex_handler_android_; 254 255 // Last status notification timestamp used for throttling. Use monotonic 256 // TimeTicks to ensure that notifications are sent even if the system clock is 257 // set back in the middle of an update. 258 base::TimeTicks last_notify_time_; 259 260 // The processor for running Actions. 261 std::unique_ptr<ActionProcessor> processor_; 262 263 // The InstallPlan used during the ongoing update. 264 InstallPlan install_plan_; 265 266 // For status: 267 UpdateStatus status_{UpdateStatus::IDLE}; 268 double download_progress_{0.0}; 269 270 // The offset in the payload file where the CrAU part starts. 271 int64_t base_offset_{0}; 272 273 // Helper class to select the network to use during the update. 274 std::unique_ptr<NetworkSelectorInterface> network_selector_; 275 276 std::unique_ptr<ClockInterface> clock_; 277 278 std::unique_ptr<MetricsReporterInterface> metrics_reporter_; 279 280 ::android::base::unique_fd payload_fd_; 281 282 std::vector<std::unique_ptr<CleanupSuccessfulUpdateCallbackInterface>> 283 cleanup_previous_update_callbacks_; 284 // Result of previous CleanupPreviousUpdateAction. Nullopt If 285 // CleanupPreviousUpdateAction has not been executed. 286 std::optional<ErrorCode> cleanup_previous_update_code_{std::nullopt}; 287 288 // The path to the zip file with X509 certificates. 289 std::string update_certificates_path_{constants::kUpdateCertificatesPath}; 290 291 metrics_utils::PersistedValue<int64_t> metric_bytes_downloaded_; 292 metrics_utils::PersistedValue<int64_t> metric_total_bytes_downloaded_; 293 294 DISALLOW_COPY_AND_ASSIGN(UpdateAttempterAndroid); 295 }; 296 297 } // namespace chromeos_update_engine 298 299 #endif // UPDATE_ENGINE_AOSP_UPDATE_ATTEMPTER_ANDROID_H_ 300