1 // 2 // Copyright (C) 2012 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_FILESYSTEM_VERIFIER_ACTION_H_ 18 #define UPDATE_ENGINE_PAYLOAD_CONSUMER_FILESYSTEM_VERIFIER_ACTION_H_ 19 20 #include <sys/stat.h> 21 #include <sys/types.h> 22 23 #include <string> 24 #include <vector> 25 26 #include <brillo/streams/stream.h> 27 28 #include "update_engine/common/action.h" 29 #include "update_engine/common/hash_calculator.h" 30 #include "update_engine/payload_consumer/install_plan.h" 31 32 // This action will hash all the partitions of the target slot involved in the 33 // update. The hashes are then verified against the ones in the InstallPlan. 34 // If the target hash does not match, the action will fail. In case of failure, 35 // the error code will depend on whether the source slot hashes are provided and 36 // match. 37 38 namespace chromeos_update_engine { 39 40 // The step FilesystemVerifier is on. On kVerifyTargetHash it computes the hash 41 // on the target partitions based on the already populated size and verifies it 42 // matches the one in the target_hash in the InstallPlan. 43 // If the hash matches, then we skip the kVerifySourceHash step, otherwise we 44 // need to check if the source is the root cause of the mismatch. 45 enum class VerifierStep { 46 kVerifyTargetHash, 47 kVerifySourceHash, 48 }; 49 50 class FilesystemVerifierAction : public InstallPlanAction { 51 public: 52 FilesystemVerifierAction() = default; 53 54 void PerformAction() override; 55 void TerminateProcessing() override; 56 57 // Used for testing. Return true if Cleanup() has not yet been called due 58 // to a callback upon the completion or cancellation of the verifier action. 59 // A test should wait until IsCleanupPending() returns false before 60 // terminating the main loop. 61 bool IsCleanupPending() const; 62 63 // Debugging/logging 64 static std::string StaticType() { return "FilesystemVerifierAction"; } 65 std::string Type() const override { return StaticType(); } 66 67 private: 68 // Starts the hashing of the current partition. If there aren't any partitions 69 // remaining to be hashed, it finishes the action. 70 void StartPartitionHashing(); 71 72 // Schedules the asynchronous read of the filesystem. 73 void ScheduleRead(); 74 75 // Called from the main loop when a single read from |src_stream_| succeeds or 76 // fails, calling OnReadDoneCallback() and OnReadErrorCallback() respectively. 77 void OnReadDoneCallback(size_t bytes_read); 78 void OnReadErrorCallback(const brillo::Error* error); 79 80 // When the read is done, finalize the hash checking of the current partition 81 // and continue checking the next one. 82 void FinishPartitionHashing(); 83 84 // Cleans up all the variables we use for async operations and tells the 85 // ActionProcessor we're done w/ |code| as passed in. |cancelled_| should be 86 // true if TerminateProcessing() was called. 87 void Cleanup(ErrorCode code); 88 89 // The type of the partition that we are verifying. 90 VerifierStep verifier_step_ = VerifierStep::kVerifyTargetHash; 91 92 // The index in the install_plan_.partitions vector of the partition currently 93 // being hashed. 94 size_t partition_index_{0}; 95 96 // If not null, the FileStream used to read from the device. 97 brillo::StreamPtr src_stream_; 98 99 // Buffer for storing data we read. 100 brillo::Blob buffer_; 101 102 bool read_done_{false}; // true if reached EOF on the input stream. 103 bool cancelled_{false}; // true if the action has been cancelled. 104 105 // The install plan we're passed in via the input pipe. 106 InstallPlan install_plan_; 107 108 // Calculates the hash of the data. 109 std::unique_ptr<HashCalculator> hasher_; 110 111 // Reads and hashes this many bytes from the head of the input stream. This 112 // field is initialized from the corresponding InstallPlan::Partition size, 113 // when the partition starts to be hashed. 114 int64_t remaining_size_{0}; 115 116 DISALLOW_COPY_AND_ASSIGN(FilesystemVerifierAction); 117 }; 118 119 } // namespace chromeos_update_engine 120 121 #endif // UPDATE_ENGINE_PAYLOAD_CONSUMER_FILESYSTEM_VERIFIER_ACTION_H_ 122
