1 // 2 // Copyright (C) 2010 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_PAYLOAD_CONSUMER_POSTINSTALL_RUNNER_ACTION_H_ 18 #define UPDATE_ENGINE_PAYLOAD_CONSUMER_POSTINSTALL_RUNNER_ACTION_H_ 19 20 #include <memory> 21 #include <string> 22 #include <utility> 23 #include <vector> 24 25 #include <base/files/file_descriptor_watcher_posix.h> 26 #include <brillo/message_loops/message_loop.h> 27 #include <gtest/gtest_prod.h> 28 29 #include "update_engine/common/action.h" 30 #include "update_engine/common/boot_control_interface.h" 31 #include "update_engine/common/hardware_interface.h" 32 #include "update_engine/payload_consumer/install_plan.h" 33 34 // The Postinstall Runner Action is responsible for running the postinstall 35 // script of a successfully downloaded update. 36 37 namespace chromeos_update_engine { 38 39 class BootControlInterface; 40 41 class PostinstallRunnerAction : public InstallPlanAction { 42 public: 43 PostinstallRunnerAction(BootControlInterface* boot_control, 44 HardwareInterface* hardware); 45 46 // InstallPlanAction overrides. 47 void PerformAction() override; 48 void SuspendAction() override; 49 void ResumeAction() override; 50 void TerminateProcessing() override; 51 52 class DelegateInterface { 53 public: 54 virtual ~DelegateInterface() = default; 55 56 // Called whenever there is an overall progress update from the postinstall 57 // programs. 58 virtual void ProgressUpdate(double progress) = 0; 59 }; 60 set_delegate(DelegateInterface * delegate)61 void set_delegate(DelegateInterface* delegate) { delegate_ = delegate; } 62 63 // Debugging/logging StaticType()64 static std::string StaticType() { return "PostinstallRunnerAction"; } Type()65 std::string Type() const override { return StaticType(); } 66 67 private: 68 friend class PostinstallRunnerActionTest; 69 FRIEND_TEST(PostinstallRunnerActionTest, ProcessProgressLineTest); 70 71 // exposed for testing purposes only SetMountDir(std::string dir)72 void SetMountDir(std::string dir) { fs_mount_dir_ = std::move(dir); } 73 void EnsureUnmounted(); 74 75 void PerformPartitionPostinstall(); 76 [[nodiscard]] bool MountPartition( 77 const InstallPlan::Partition& partition) noexcept; 78 79 // Called whenever the |progress_fd_| has data available to read. 80 void OnProgressFdReady(); 81 82 // Updates the action progress according to the |line| passed from the 83 // postinstall program. Valid lines are: 84 // global_progress <frac> 85 // <frac> should be between 0.0 and 1.0; sets the progress to the 86 // <frac> value. 87 bool ProcessProgressLine(const std::string& line); 88 89 // Report the progress to the delegate given that the postinstall operation 90 // for |current_partition_| has a current progress of |frac|, a value between 91 // 0 and 1 for that step. 92 void ReportProgress(double frac); 93 94 // Cleanup the setup made when running postinstall for a given partition. 95 // Unmount and remove the mountpoint directory if needed and cleanup the 96 // status file descriptor and message loop task watching for it. 97 void Cleanup(); 98 99 // Subprocess::Exec callback. 100 void CompletePartitionPostinstall(int return_code, const std::string& output); 101 102 // Complete the Action with the passed |error_code| and mark the new slot as 103 // ready. Called when the post-install script was run for all the partitions. 104 void CompletePostinstall(ErrorCode error_code); 105 106 // The path where the filesystem will be mounted during post-install. 107 std::string fs_mount_dir_; 108 109 // The partition being processed on the list of partitions specified in the 110 // InstallPlan. 111 size_t current_partition_{0}; 112 113 // A non-negative value representing the estimated weight of each partition 114 // passed in the install plan. The weight is used to predict the overall 115 // progress from the individual progress of each partition and should 116 // correspond to the time it takes to run it. 117 std::vector<double> partition_weight_; 118 119 // The sum of all the weights in |partition_weight_|. 120 double total_weight_{0}; 121 122 // The sum of all the weights in |partition_weight_| up to but not including 123 // the |current_partition_|. 124 double accumulated_weight_{0}; 125 126 // The delegate used to notify of progress updates, if any. 127 DelegateInterface* delegate_{nullptr}; 128 129 // The BootControlInerface used to mark the new slot as ready. 130 BootControlInterface* boot_control_; 131 132 // HardwareInterface used to signal powerwash. 133 HardwareInterface* hardware_; 134 135 // Whether the Powerwash was scheduled before invoking post-install script. 136 // Used for cleaning up if post-install fails. 137 bool powerwash_scheduled_{false}; 138 139 // Postinstall command currently running, or 0 if no program running. 140 pid_t current_command_{0}; 141 142 // True if |current_command_| has been suspended by SuspendAction(). 143 bool is_current_command_suspended_{false}; 144 145 // The parent progress file descriptor used to watch for progress reports from 146 // the postinstall program and the task watching for them. 147 int progress_fd_{-1}; 148 149 std::unique_ptr<base::FileDescriptorWatcher::Controller> progress_controller_; 150 151 // A buffer of a partial read line from the progress file descriptor. 152 std::string progress_buffer_; 153 154 DISALLOW_COPY_AND_ASSIGN(PostinstallRunnerAction); 155 }; 156 157 } // namespace chromeos_update_engine 158 159 #endif // UPDATE_ENGINE_PAYLOAD_CONSUMER_POSTINSTALL_RUNNER_ACTION_H_ 160