platform_system_vold/EncryptInplace.cpp

/*
 * Copyright (C) 2016 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 "EncryptInplace.h"

#include <ext4_utils/ext4.h>
#include <ext4_utils/ext4_utils.h>
#include <f2fs_sparseblock.h>
#include <fcntl.h>
#include <time.h>

#include <algorithm>
#include <vector>

#include <android-base/logging.h>
#include <android-base/properties.h>
#include <android-base/unique_fd.h>

enum EncryptInPlaceError {
    kSuccess,
    kFailed,
    kFilesystemNotFound,
};

static uint64_t round_up(uint64_t val, size_t amount) {
    if (val % amount) val += amount - (val % amount);
    return val;
}

class InPlaceEncrypter {
  public:
    bool EncryptInPlace(const std::string& crypto_blkdev, const std::string& real_blkdev,
                        uint64_t nr_sec, bool set_progress_properties);
    bool ProcessUsedBlock(uint64_t block_num);

  private:
    // aligned 32K writes tends to make flash happy.
    // SD card association recommends it.
    static const size_t kIOBufferSize = 32768;

    // Avoid spamming the logs.  Print the "Encrypting blocks" log message once
    // every 10000 blocks (which is usually every 40 MB or so), and once at the end.
    static const int kLogInterval = 10000;

    std::string DescribeFilesystem();
    void InitFs(const std::string& fs_type, uint64_t blocks_to_encrypt, uint64_t total_blocks,
                unsigned int block_size);
    void UpdateProgress(size_t blocks, bool done);
    bool EncryptPendingData();
    bool DoEncryptInPlace();

    // ext4 methods
    bool ReadExt4BlockBitmap(uint32_t group, uint8_t* buf);
    uint64_t FirstBlockInGroup(uint32_t group);
    uint32_t NumBlocksInGroup(uint32_t group);
    uint32_t NumBaseMetaBlocksInGroup(uint64_t group);
    EncryptInPlaceError EncryptInPlaceExt4();

    // f2fs methods
    EncryptInPlaceError EncryptInPlaceF2fs();

    std::string real_blkdev_;
    std::string crypto_blkdev_;
    uint64_t nr_sec_;
    bool set_progress_properties_;

    android::base::unique_fd realfd_;
    android::base::unique_fd cryptofd_;

    time_t time_started_;
    int remaining_time_;

    std::string fs_type_;
    uint64_t blocks_done_;
    uint64_t blocks_to_encrypt_;
    unsigned int block_size_;
    unsigned int cur_pct_;

    std::vector<uint8_t> io_buffer_;
    uint64_t first_pending_block_;
    size_t blocks_pending_;
};

std::string InPlaceEncrypter::DescribeFilesystem() {
    if (fs_type_.empty())
        return "full block device " + real_blkdev_;
    else
        return fs_type_ + " filesystem on " + real_blkdev_;
}

// Finishes initializing the encrypter, now that the filesystem details are known.
void InPlaceEncrypter::InitFs(const std::string& fs_type, uint64_t blocks_to_encrypt,
                              uint64_t total_blocks, unsigned int block_size) {
    fs_type_ = fs_type;
    blocks_done_ = 0;
    blocks_to_encrypt_ = blocks_to_encrypt;
    block_size_ = block_size;
    cur_pct_ = 0;

    // Allocate the I/O buffer.  kIOBufferSize should always be a multiple of
    // the filesystem block size, but round it up just in case.
    io_buffer_.resize(round_up(kIOBufferSize, block_size));
    first_pending_block_ = 0;
    blocks_pending_ = 0;

    LOG(INFO) << "Encrypting " << DescribeFilesystem() << " in-place via " << crypto_blkdev_;
    LOG(INFO) << blocks_to_encrypt << " blocks (" << (blocks_to_encrypt * block_size) / 1000000
              << " MB) of " << total_blocks << " blocks are in-use";
}

void InPlaceEncrypter::UpdateProgress(size_t blocks, bool done) {
    // A log message already got printed for blocks_done_ if one was due, so the
    // next message will be due at the *next* block rounded up to kLogInterval.
    uint64_t blocks_next_msg = round_up(blocks_done_ + 1, kLogInterval);

    blocks_done_ += blocks;

    // Ensure that a log message gets printed at the end, but not if one was
    // already printed due to the block count being a multiple of kLogInterval.
    // E.g. we want to show "50000 of 50327" and then "50327 of "50327", but not
    // "50000 of 50000" and then redundantly "50000 of 50000" again.
    if (done && blocks_done_ % kLogInterval != 0) blocks_next_msg = blocks_done_;

    if (blocks_done_ >= blocks_next_msg)
        LOG(DEBUG) << "Encrypted " << blocks_next_msg << " of " << blocks_to_encrypt_ << " blocks";

    if (!set_progress_properties_) return;

    uint64_t new_pct;
    if (done) {
        new_pct = 100;
    } else {
        new_pct = (blocks_done_ * 100) / std::max<uint64_t>(blocks_to_encrypt_, 1);
        new_pct = std::min<uint64_t>(new_pct, 99);
    }
    if (new_pct > cur_pct_) {
        cur_pct_ = new_pct;
        android::base::SetProperty("vold.encrypt_progress", std::to_string(new_pct));
    }

    if (cur_pct_ >= 5) {
        struct timespec time_now;
        if (clock_gettime(CLOCK_MONOTONIC, &time_now)) {
            PLOG(WARNING) << "Error getting time while updating encryption progress";
        } else {
            double elapsed_time = difftime(time_now.tv_sec, time_started_);

            uint64_t remaining_blocks = 0;
            if (blocks_done_ < blocks_to_encrypt_)
                remaining_blocks = blocks_to_encrypt_ - blocks_done_;

            int remaining_time = 0;
            if (blocks_done_ != 0)
                remaining_time = (int)(elapsed_time * remaining_blocks / blocks_done_);

            // Change time only if not yet set, lower, or a lot higher for
            // best user experience
            if (remaining_time_ == -1 || remaining_time < remaining_time_ ||
                remaining_time > remaining_time_ + 60) {
                remaining_time_ = remaining_time;
                android::base::SetProperty("vold.encrypt_time_remaining",
                                           std::to_string(remaining_time));
            }
        }
    }
}

bool InPlaceEncrypter::EncryptPendingData() {
    if (blocks_pending_ == 0) return true;

    ssize_t bytes = blocks_pending_ * block_size_;
    uint64_t offset = first_pending_block_ * block_size_;

    if (pread64(realfd_, &io_buffer_[0], bytes, offset) != bytes) {
        PLOG(ERROR) << "Error reading real_blkdev " << real_blkdev_ << " for inplace encrypt";
        return false;
    }

    if (pwrite64(cryptofd_, &io_buffer_[0], bytes, offset) != bytes) {
        PLOG(ERROR) << "Error writing crypto_blkdev " << crypto_blkdev_ << " for inplace encrypt";
        return false;
    }

    UpdateProgress(blocks_pending_, false);

    blocks_pending_ = 0;
    return true;
}

bool InPlaceEncrypter::ProcessUsedBlock(uint64_t block_num) {
    // Flush if the amount of pending data has reached the I/O buffer size, if
    // there's a gap between the pending blocks and the next block (due to
    // block(s) not being used by the filesystem and thus not needing
    // encryption), or if the next block will be aligned to the I/O buffer size.
    if (blocks_pending_ * block_size_ == io_buffer_.size() ||
        block_num != first_pending_block_ + blocks_pending_ ||
        (block_num * block_size_) % io_buffer_.size() == 0) {
        if (!EncryptPendingData()) return false;
        first_pending_block_ = block_num;
    }
    blocks_pending_++;
    return true;
}

// Reads the block bitmap for block group |group| into |buf|.
bool InPlaceEncrypter::ReadExt4BlockBitmap(uint32_t group, uint8_t* buf) {
    uint64_t offset = (uint64_t)aux_info.bg_desc[group].bg_block_bitmap * info.block_size;
    if (pread64(realfd_, buf, info.block_size, offset) != (ssize_t)info.block_size) {
        PLOG(ERROR) << "Failed to read block bitmap for block group " << group;
        return false;
    }
    return true;
}

uint64_t InPlaceEncrypter::FirstBlockInGroup(uint32_t group) {
    return aux_info.first_data_block + (group * (uint64_t)info.blocks_per_group);
}

uint32_t InPlaceEncrypter::NumBlocksInGroup(uint32_t group) {
    uint64_t remaining = aux_info.len_blocks - FirstBlockInGroup(group);
    return std::min<uint64_t>(info.blocks_per_group, remaining);
}

// In block groups with an uninitialized block bitmap, we only need to encrypt
// the backup superblock and the block group descriptors (if they are present).
uint32_t InPlaceEncrypter::NumBaseMetaBlocksInGroup(uint64_t group) {
    if (!ext4_bg_has_super_block(group)) return 0;
    return 1 + aux_info.bg_desc_blocks;
}

EncryptInPlaceError InPlaceEncrypter::EncryptInPlaceExt4() {
    if (setjmp(setjmp_env))  // NOLINT
        return kFilesystemNotFound;

    if (read_ext(realfd_, 0) != 0) return kFilesystemNotFound;

    LOG(DEBUG) << "ext4 filesystem has " << aux_info.groups << " block groups";

    uint64_t blocks_to_encrypt = 0;
    for (uint32_t group = 0; group < aux_info.groups; group++) {
        if (aux_info.bg_desc[group].bg_flags & EXT4_BG_BLOCK_UNINIT)
            blocks_to_encrypt += NumBaseMetaBlocksInGroup(group);
        else
            blocks_to_encrypt +=
                    (NumBlocksInGroup(group) - aux_info.bg_desc[group].bg_free_blocks_count);
    }

    InitFs("ext4", blocks_to_encrypt, aux_info.len_blocks, info.block_size);

    // Encrypt each block group.
    std::vector<uint8_t> block_bitmap(info.block_size);
    for (uint32_t group = 0; group < aux_info.groups; group++) {
        if (!ReadExt4BlockBitmap(group, &block_bitmap[0])) return kFailed;

        uint64_t first_block_num = FirstBlockInGroup(group);
        bool uninit = (aux_info.bg_desc[group].bg_flags & EXT4_BG_BLOCK_UNINIT);
        uint32_t block_count = uninit ? NumBaseMetaBlocksInGroup(group) : NumBlocksInGroup(group);

        // Encrypt each used block in the block group.
        for (uint32_t i = 0; i < block_count; i++) {
            if (uninit || bitmap_get_bit(&block_bitmap[0], i))
                ProcessUsedBlock(first_block_num + i);
        }
    }
    return kSuccess;
}

static int encrypt_f2fs_block(uint64_t block_num, void* _encrypter) {
    InPlaceEncrypter* encrypter = reinterpret_cast<InPlaceEncrypter*>(_encrypter);
    if (!encrypter->ProcessUsedBlock(block_num)) return -1;
    return 0;
}

EncryptInPlaceError InPlaceEncrypter::EncryptInPlaceF2fs() {
    std::unique_ptr<struct f2fs_info, void (*)(struct f2fs_info*)> fs_info(
            generate_f2fs_info(realfd_), free_f2fs_info);
    if (!fs_info) return kFilesystemNotFound;

    InitFs("f2fs", get_num_blocks_used(fs_info.get()), fs_info->total_blocks, fs_info->block_size);
    if (run_on_used_blocks(0, fs_info.get(), encrypt_f2fs_block, this) != 0) return kFailed;
    return kSuccess;
}

bool InPlaceEncrypter::DoEncryptInPlace() {
    EncryptInPlaceError rc;

    rc = EncryptInPlaceExt4();
    if (rc != kFilesystemNotFound) return rc == kSuccess;

    rc = EncryptInPlaceF2fs();
    if (rc != kFilesystemNotFound) return rc == kSuccess;

    LOG(WARNING) << "No recognized filesystem found on " << real_blkdev_
                 << ".  Falling back to encrypting the full block device.";
    InitFs("", nr_sec_, nr_sec_, 512);
    for (uint64_t i = 0; i < nr_sec_; i++) {
        if (!ProcessUsedBlock(i)) return false;
    }
    return true;
}

bool InPlaceEncrypter::EncryptInPlace(const std::string& crypto_blkdev,
                                      const std::string& real_blkdev, uint64_t nr_sec,
                                      bool set_progress_properties) {
    struct timespec time_started = {0};

    real_blkdev_ = real_blkdev;
    crypto_blkdev_ = crypto_blkdev;
    nr_sec_ = nr_sec;
    set_progress_properties_ = set_progress_properties;

    realfd_.reset(open64(real_blkdev.c_str(), O_RDONLY | O_CLOEXEC));
    if (realfd_ < 0) {
        PLOG(ERROR) << "Error opening real_blkdev " << real_blkdev << " for inplace encrypt";
        return false;
    }

    cryptofd_.reset(open64(crypto_blkdev.c_str(), O_WRONLY | O_CLOEXEC));
    if (cryptofd_ < 0) {
        PLOG(ERROR) << "Error opening crypto_blkdev " << crypto_blkdev << " for inplace encrypt";
        return false;
    }

    if (clock_gettime(CLOCK_MONOTONIC, &time_started)) {
        PLOG(WARNING) << "Error getting time at start of in-place encryption";
        // Note - continue anyway - we'll run with 0
    }
    time_started_ = time_started.tv_sec;
    remaining_time_ = -1;

    bool success = DoEncryptInPlace();

    if (success) success &= EncryptPendingData();

    if (!success) {
        LOG(ERROR) << "In-place encryption of " << DescribeFilesystem() << " failed";
        return false;
    }
    if (blocks_done_ != blocks_to_encrypt_) {
        LOG(WARNING) << "blocks_to_encrypt (" << blocks_to_encrypt_
                     << ") was incorrect; we actually encrypted " << blocks_done_
                     << " blocks.  Encryption progress was inaccurate";
    }
    // Make sure vold.encrypt_progress gets set to 100.
    UpdateProgress(0, true);
    LOG(INFO) << "Successfully encrypted " << DescribeFilesystem();
    return true;
}

// Encrypts |real_blkdev| in-place by reading the data from |real_blkdev| and
// writing it to |crypto_blkdev|, which should be a dm-crypt or dm-default-key
// device backed by |real_blkdev|.  The size to encrypt is |nr_sec| 512-byte
// sectors; however, if a filesystem is detected, then its size will be used
// instead, and only the in-use blocks of the filesystem will be encrypted.
bool encrypt_inplace(const std::string& crypto_blkdev, const std::string& real_blkdev,
                     uint64_t nr_sec, bool set_progress_properties) {
    LOG(DEBUG) << "encrypt_inplace(" << crypto_blkdev << ", " << real_blkdev << ", " << nr_sec
               << ", " << (set_progress_properties ? "true" : "false") << ")";

    InPlaceEncrypter encrypter;
    return encrypter.EncryptInPlace(crypto_blkdev, real_blkdev, nr_sec, set_progress_properties);
}