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 38namespace 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. 45enum class VerifierStep { 46 kVerifyTargetHash, 47 kVerifySourceHash, 48}; 49 50class 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