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