zircon/system/utest/fs-recovery/recovery.cpp

// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <fcntl.h>

#include <fs-management/fvm.h>
#include <fs-management/mount.h>
#include <fvm/format.h>
#include <lib/devmgr-integration-test/fixture.h>
#include <lib/fdio/fd.h>
#include <lib/fdio/fdio.h>
#include <lib/fzl/fdio.h>
#include <lib/zx/vmo.h>
#include <ramdevice-client/ramdisk.h>
#include <unittest/unittest.h>

namespace {

using devmgr_integration_test::IsolatedDevmgr;

const uint32_t kBlockCount = 1024 * 256;
const uint32_t kBlockSize = 512;
const uint32_t kSliceSize = (1 << 20);
const size_t kDeviceSize = kBlockCount * kBlockSize;
const char* kDataName = "fs-recovery-data";
const char* kRamdiskPath = "misc/ramctl";

// Test fixture that builds a ramdisk and destroys it when destructed.
class FsRecoveryTest {
public:
    // Create an IsolatedDevmgr that can load device drivers such as fvm,
    // zxcrypt, etc.
    bool Initialize() {
        BEGIN_HELPER;
        auto args = IsolatedDevmgr::DefaultArgs();
        args.disable_block_watcher = false;
        args.sys_device_driver = devmgr_integration_test::IsolatedDevmgr::kSysdevDriver;
        args.load_drivers.push_back(devmgr_integration_test::IsolatedDevmgr::kSysdevDriver);
        args.driver_search_paths.push_back("/boot/driver");
        ASSERT_EQ(IsolatedDevmgr::Create(std::move(args), &devmgr_), ZX_OK);
        END_HELPER;
    }

    // Create a ram disk that is back by a VMO, which is formatted to look like
    // an FVM volume.
    bool CreateFvmRamdisk(size_t device_size, size_t block_size) {
        BEGIN_HELPER;

        // Calculate total size of data + metadata.
        device_size = fbl::round_up(device_size, fvm::kBlockSize);
        size_t old_meta = fvm::MetadataSize(device_size, fvm::kBlockSize);
        size_t new_meta = fvm::MetadataSize(old_meta + device_size, fvm::kBlockSize);
        while (old_meta != new_meta) {
            old_meta = new_meta;
            new_meta = fvm::MetadataSize(old_meta + device_size, fvm::kBlockSize);
        }
        device_size = device_size + (new_meta * 2);

        zx::vmo disk;
        ASSERT_EQ(zx::vmo::create(device_size, 0, &disk), ZX_OK);
        int fd = -1;
        ASSERT_EQ(fdio_fd_create(disk.get(), &fd), ZX_OK);
        ASSERT_GE(fd, 0);
        ASSERT_EQ(fvm_init_with_size(fd, device_size, kSliceSize), ZX_OK);

        fbl::unique_fd ramdisk;
        ASSERT_TRUE(WaitForDevice(kRamdiskPath, &ramdisk));

        ASSERT_EQ(ramdisk_create_at_from_vmo(devmgr_.devfs_root().get(), disk.get(),
                                             &ramdisk_client_),
                  ZX_OK);
        END_HELPER;
    }

    // Create a partition in the FVM volume that has the data guid.
    bool CreateFvmPartition(char* fvm_block_path) {
        BEGIN_HELPER;

        char fvm_path[PATH_MAX];
        snprintf(fvm_path, PATH_MAX, "%s/fvm", ramdisk_get_path(ramdisk_client_));
        fbl::unique_fd fvm_fd;
        ASSERT_TRUE(WaitForDevice(fvm_path, &fvm_fd));

        // Allocate a FVM partition with the data guid but don't actually format the
        // partition.
        alloc_req_t req;
        memset(&req, 0, sizeof(alloc_req_t));
        req.slice_count = 1;
        static const uint8_t data_guid[GPT_GUID_LEN] = GUID_DATA_VALUE;
        memcpy(req.type, data_guid, GUID_LEN);
        snprintf(req.name, NAME_LEN, "%s", kDataName);

        fuchsia_hardware_block_partition_GUID type_guid;
        memcpy(type_guid.value, req.type, GUID_LEN);
        fuchsia_hardware_block_partition_GUID instance_guid;
        memcpy(instance_guid.value, req.guid, GUID_LEN);

        fzl::UnownedFdioCaller caller(fvm_fd.get());
        zx_status_t status;
        ASSERT_EQ(fuchsia_hardware_block_volume_VolumeManagerAllocatePartition(
                      caller.borrow_channel(), req.slice_count, &type_guid, &instance_guid,
                      req.name, NAME_LEN, req.flags, &status),
                  ZX_OK);
        ASSERT_EQ(status, ZX_OK);

        snprintf(fvm_block_path, PATH_MAX, "%s/%s-p-1/block", fvm_path, kDataName);
        fbl::unique_fd fvm_block_fd;
        ASSERT_TRUE(WaitForDevice(fvm_block_path, &fvm_block_fd));

        END_HELPER;
    }

    // Wait for the device to be available and then check to make sure it is
    // formatted of the passed in type. Since formatting can take some time
    // after the device becomes available, we must recheck.
    bool WaitForDiskFormat(const char* path, disk_format_t format, zx::duration deadline) {
        fbl::unique_fd fd;
        if (!WaitForDevice(path, &fd)) {
            return false;
        }
        while (deadline.get() > 0) {
            fd.reset(openat(devmgr_.devfs_root().get(), path, O_RDONLY));
            if (detect_disk_format(fd.get()) == format)
                return true;
            sleep(1);
            deadline -= zx::duration(ZX_SEC(1));
        }
        return false;
    }

private:
    bool WaitForDevice(const char* path, fbl::unique_fd* fd) {
        BEGIN_HELPER;
        printf("Wait for device %s\n", path);
        ASSERT_EQ(devmgr_integration_test::RecursiveWaitForFile(devmgr_.devfs_root(), path, fd),
                  ZX_OK);

        ASSERT_TRUE(*fd);
        END_HELPER;
    }

    ramdisk_client_t* ramdisk_client_;
    devmgr_integration_test::IsolatedDevmgr devmgr_;
};

bool EmptyPartitionRecoveryTest() {
    BEGIN_TEST;

    char fvm_block_path[PATH_MAX];
    fbl::unique_ptr<FsRecoveryTest> recovery(new FsRecoveryTest());
    ASSERT_TRUE(recovery->Initialize());
    // Creates an FVM partition under an isolated devmgr. It creates, but does
    // not properly format the data partition.
    ASSERT_TRUE(recovery->CreateFvmRamdisk(kDeviceSize, kBlockSize));
    ASSERT_TRUE(recovery->CreateFvmPartition(fvm_block_path));

    // We then expect the devmgr to self-recover, i.e., format the zxcrypt/data
    // partitions as expected from the FVM partition.

    // First, wait for the zxcrypt partition to be formatted.
    EXPECT_TRUE(recovery->WaitForDiskFormat(fvm_block_path, DISK_FORMAT_ZXCRYPT,
                                            zx::duration(ZX_SEC(3))));

    // Second, wait for the data partition to be formatted.
    char data_path[PATH_MAX];
    snprintf(data_path, sizeof(data_path),
             "%s/zxcrypt/unsealed/block", fvm_block_path);
    EXPECT_TRUE(recovery->WaitForDiskFormat(data_path, DISK_FORMAT_MINFS,
                                            zx::duration(ZX_SEC(3))));

    END_TEST;
}

BEGIN_TEST_CASE(FsRecoveryTest)
RUN_TEST(EmptyPartitionRecoveryTest)
END_TEST_CASE(FsRecoveryTest)

} // namespace