Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit fedb2709 authored by Yifan Hong's avatar Yifan Hong
Browse files

libsnapshot: Add SnapshotManagerStub. 

Avoid crashes in update_engine. When SnapshotManager
should not be used (e.g. Virtual A/B is not enabled),
use the stub instead.

Bug: 148956645
Test: update_engine_unittests
Change-Id: Id524a1dfe5d085d439fc5492d4b7f72ee583c17e
parent 8129dda1

fs_mgr/libsnapshot/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -73,6 +73,7 @@ filegroup { 
        "device_info.cpp",

        "snapshot.cpp",

        "snapshot_stats.cpp",

        "snapshot_stub.cpp",

        "snapshot_metadata_updater.cpp",

        "partition_cow_creator.cpp",

        "return.cpp",

fs_mgr/libsnapshot/include/libsnapshot/snapshot_stub.h

0 → 100644
+51 −0
Original line number Diff line number Diff line 
// Copyright (C) 2020 The Android Open Source Project

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//      http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.



#pragma once



#include <libsnapshot/snapshot.h>



namespace android::snapshot {



class SnapshotManagerStub : public ISnapshotManager {

  public:

    // Create a stubbed snapshot manager. All calls into the stub fails.

    static std::unique_ptr<ISnapshotManager> New();



    // ISnapshotManager overrides.

    bool BeginUpdate() override;

    bool CancelUpdate() override;

    bool FinishedSnapshotWrites(bool wipe) override;

    bool InitiateMerge() override;

    UpdateState ProcessUpdateState(const std::function<bool()>& callback = {},

                                   const std::function<bool()>& before_cancel = {}) override;

    UpdateState GetUpdateState(double* progress = nullptr) override;

    Return CreateUpdateSnapshots(

            const chromeos_update_engine::DeltaArchiveManifest& manifest) override;

    bool MapUpdateSnapshot(const android::fs_mgr::CreateLogicalPartitionParams& params,

                           std::string* snapshot_path) override;

    bool UnmapUpdateSnapshot(const std::string& target_partition_name) override;

    bool NeedSnapshotsInFirstStageMount() override;

    bool CreateLogicalAndSnapshotPartitions(

            const std::string& super_device,

            const std::chrono::milliseconds& timeout_ms = {}) override;

    bool HandleImminentDataWipe(const std::function<void()>& callback = {}) override;

    CreateResult RecoveryCreateSnapshotDevices() override;

    CreateResult RecoveryCreateSnapshotDevices(

            const std::unique_ptr<AutoDevice>& metadata_device) override;

    bool Dump(std::ostream& os) override;

    std::unique_ptr<AutoDevice> EnsureMetadataMounted() override;

};



}  // namespace android::snapshot

fs_mgr/libsnapshot/snapshot_stub.cpp

0 → 100644
+111 −0
Original line number Diff line number Diff line 
// Copyright (C) 2020 The Android Open Source Project

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//      http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.



#include <libsnapshot/snapshot_stub.h>



#include <android-base/logging.h>



using android::fs_mgr::CreateLogicalPartitionParams;

using chromeos_update_engine::DeltaArchiveManifest;



namespace android::snapshot {



std::unique_ptr<ISnapshotManager> SnapshotManagerStub::New() {

    return std::make_unique<SnapshotManagerStub>();

}



bool SnapshotManagerStub::BeginUpdate() {

    LOG(ERROR) << __FUNCTION__ << " should never be called.";

    return false;

}



bool SnapshotManagerStub::CancelUpdate() {

    LOG(ERROR) << __FUNCTION__ << " should never be called.";

    return false;

}



bool SnapshotManagerStub::FinishedSnapshotWrites(bool) {

    LOG(ERROR) << __FUNCTION__ << " should never be called.";

    return false;

}



bool SnapshotManagerStub::InitiateMerge() {

    LOG(ERROR) << __FUNCTION__ << " should never be called.";

    return false;

}



UpdateState SnapshotManagerStub::ProcessUpdateState(const std::function<bool()>&,

                                                    const std::function<bool()>&) {

    LOG(ERROR) << __FUNCTION__ << " should never be called.";

    return UpdateState::None;

}



UpdateState SnapshotManagerStub::GetUpdateState(double*) {

    LOG(ERROR) << __FUNCTION__ << " should never be called.";

    return UpdateState::None;

}



Return SnapshotManagerStub::CreateUpdateSnapshots(const DeltaArchiveManifest&) {

    LOG(ERROR) << __FUNCTION__ << " should never be called.";

    return Return::Error();

}



bool SnapshotManagerStub::MapUpdateSnapshot(const CreateLogicalPartitionParams&, std::string*) {

    LOG(ERROR) << __FUNCTION__ << " should never be called.";

    return false;

}



bool SnapshotManagerStub::UnmapUpdateSnapshot(const std::string&) {

    LOG(ERROR) << __FUNCTION__ << " should never be called.";

    return false;

}



bool SnapshotManagerStub::NeedSnapshotsInFirstStageMount() {

    LOG(ERROR) << __FUNCTION__ << " should never be called.";

    return false;

}



bool SnapshotManagerStub::CreateLogicalAndSnapshotPartitions(const std::string&,

                                                             const std::chrono::milliseconds&) {

    LOG(ERROR) << __FUNCTION__ << " should never be called.";

    return false;

}



bool SnapshotManagerStub::HandleImminentDataWipe(const std::function<void()>&) {

    LOG(ERROR) << __FUNCTION__ << " should never be called.";

    return false;

}



CreateResult SnapshotManagerStub::RecoveryCreateSnapshotDevices() {

    LOG(ERROR) << __FUNCTION__ << " should never be called.";

    return CreateResult::ERROR;

}



CreateResult SnapshotManagerStub::RecoveryCreateSnapshotDevices(

        const std::unique_ptr<AutoDevice>&) {

    LOG(ERROR) << __FUNCTION__ << " should never be called.";

    return CreateResult::ERROR;

}



bool SnapshotManagerStub::Dump(std::ostream&) {

    LOG(ERROR) << __FUNCTION__ << " should never be called.";

    return false;

}



std::unique_ptr<AutoDevice> SnapshotManagerStub::EnsureMetadataMounted() {

    LOG(ERROR) << __FUNCTION__ << " should never be called.";

    return nullptr;

}



}  // namespace android::snapshot