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