| // Copyright 2018 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 <lib/paver/device-partitioner.h> |
| |
| #include <dirent.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <libgen.h> |
| |
| #include <chromeos-disk-setup/chromeos-disk-setup.h> |
| #include <fbl/auto_call.h> |
| #include <fbl/function.h> |
| #include <fs-management/fvm.h> |
| #include <fuchsia/device/c/fidl.h> |
| #include <fuchsia/hardware/block/c/fidl.h> |
| #include <fuchsia/hardware/skipblock/c/fidl.h> |
| #include <fuchsia/sysinfo/c/fidl.h> |
| #include <gpt/cros.h> |
| #include <lib/fdio/directory.h> |
| #include <lib/fdio/fd.h> |
| #include <lib/fdio/fdio.h> |
| #include <lib/fdio/unsafe.h> |
| #include <lib/fdio/watcher.h> |
| #include <lib/fzl/fdio.h> |
| #include <zircon/status.h> |
| #include <zxcrypt/volume.h> |
| |
| #include <utility> |
| |
| #include "pave-logging.h" |
| #include "pave-utils.h" |
| |
| namespace paver { |
| |
| bool (*TestBlockFilter)(const fbl::unique_fd&) = nullptr; |
| |
| namespace { |
| |
| constexpr char kEfiName[] = "EFI Gigaboot"; |
| constexpr char kGptDriverName[] = "/boot/driver/gpt.so"; |
| constexpr char kFvmPartitionName[] = "fvm"; |
| constexpr char kZirconAName[] = "ZIRCON-A"; |
| constexpr char kZirconBName[] = "ZIRCON-B"; |
| constexpr char kZirconRName[] = "ZIRCON-R"; |
| |
| bool KernelFilterCallback(const gpt_partition_t& part, const uint8_t kern_type[GPT_GUID_LEN], fbl::StringPiece partition_name) { |
| char cstring_name[GPT_NAME_LEN]; |
| utf16_to_cstring(cstring_name, reinterpret_cast<const uint16_t*>(part.name), GPT_NAME_LEN); |
| return memcmp(part.type, kern_type, GPT_GUID_LEN) == 0 && |
| strncmp(cstring_name, partition_name.data(), partition_name.length()) == 0; |
| } |
| |
| bool IsFvmPartition(const gpt_partition_t& part) { |
| const uint8_t partition_type[GPT_GUID_LEN] = GUID_FVM_VALUE; |
| return memcmp(part.type, partition_type, GPT_GUID_LEN) == 0; |
| } |
| |
| bool IsGigabootPartition(const gpt_partition_t& part) { |
| const uint8_t efi_type[GPT_GUID_LEN] = GUID_EFI_VALUE; |
| char cstring_name[GPT_NAME_LEN]; |
| utf16_to_cstring(cstring_name, reinterpret_cast<const uint16_t*>(part.name), GPT_NAME_LEN); |
| // Disk-paved EFI: Identified by "EFI Gigaboot" label. |
| const bool gigaboot_efi = strncmp(cstring_name, kEfiName, strlen(kEfiName)) == 0; |
| return memcmp(part.type, efi_type, GPT_GUID_LEN) == 0 && gigaboot_efi; |
| } |
| |
| constexpr size_t ReservedHeaderBlocks(size_t blk_size) { |
| constexpr size_t kReservedEntryBlocks = (16 * 1024); |
| return (kReservedEntryBlocks + 2 * blk_size) / blk_size; |
| } |
| |
| // Helper function to auto-deduce type. |
| template <typename T> |
| fbl::unique_ptr<T> WrapUnique(T* ptr) { |
| return fbl::unique_ptr<T>(ptr); |
| } |
| |
| zx_status_t OpenPartition(const fbl::unique_fd& devfs_root, const char* path, |
| fbl::Function<bool(const fbl::unique_fd&)> should_filter_file, |
| zx_duration_t timeout, fbl::unique_fd* out_partition) { |
| ZX_ASSERT(path != nullptr); |
| |
| struct CallbackInfo { |
| fbl::unique_fd* out_partition; |
| fbl::Function<bool(const fbl::unique_fd&)> should_filter_file; |
| }; |
| |
| CallbackInfo info = { |
| .out_partition = out_partition, |
| .should_filter_file = std::move(should_filter_file), |
| }; |
| |
| auto cb = [](int dirfd, int event, const char* filename, void* cookie) { |
| if (event != WATCH_EVENT_ADD_FILE) { |
| return ZX_OK; |
| } |
| if ((strcmp(filename, ".") == 0) || strcmp(filename, "..") == 0) { |
| return ZX_OK; |
| } |
| fbl::unique_fd devfd(openat(dirfd, filename, O_RDWR)); |
| if (!devfd) { |
| return ZX_OK; |
| } |
| auto info = static_cast<CallbackInfo*>(cookie); |
| if (info->should_filter_file(devfd)) { |
| return ZX_OK; |
| } |
| if (info->out_partition) { |
| *(info->out_partition) = std::move(devfd); |
| } |
| return ZX_ERR_STOP; |
| }; |
| |
| fbl::unique_fd dir_fd(openat(devfs_root.get(), path, O_RDONLY)); |
| if (!dir_fd) { |
| return ZX_ERR_IO; |
| } |
| DIR* dir = fdopendir(dir_fd.release()); |
| if (dir == nullptr) { |
| return ZX_ERR_IO; |
| } |
| const auto closer = fbl::MakeAutoCall([&dir]() { closedir(dir); }); |
| |
| zx_time_t deadline = zx_deadline_after(timeout); |
| if (fdio_watch_directory(dirfd(dir), cb, deadline, &info) != ZX_ERR_STOP) { |
| return ZX_ERR_NOT_FOUND; |
| } |
| return ZX_OK; |
| } |
| |
| constexpr char kBlockDevPath[] = "class/block/"; |
| |
| zx_status_t OpenBlockPartition(const fbl::unique_fd& devfs_root, const uint8_t* unique_guid, |
| const uint8_t* type_guid, zx_duration_t timeout, |
| fbl::unique_fd* out_fd) { |
| ZX_ASSERT(unique_guid || type_guid); |
| |
| auto cb = [&](const fbl::unique_fd& fd) { |
| if (TestBlockFilter && TestBlockFilter(fd)) { |
| return true; |
| } |
| fzl::UnownedFdioCaller caller(fd.get()); |
| zx::unowned_channel channel(caller.borrow_channel()); |
| fuchsia_hardware_block_partition_GUID guid; |
| zx_status_t io_status, status; |
| if (type_guid) { |
| io_status = fuchsia_hardware_block_partition_PartitionGetTypeGuid(channel->get(), |
| &status, &guid); |
| if (io_status != ZX_OK || status != ZX_OK || |
| memcmp(guid.value, type_guid, GUID_LEN) != 0) { |
| return true; |
| } |
| } |
| if (unique_guid) { |
| io_status = fuchsia_hardware_block_partition_PartitionGetInstanceGuid(channel->get(), |
| &status, &guid); |
| if (io_status != ZX_OK || status != ZX_OK || |
| memcmp(guid.value, unique_guid, GUID_LEN) != 0) { |
| return true; |
| } |
| } |
| return false; |
| }; |
| |
| return OpenPartition(devfs_root, kBlockDevPath, cb, timeout, out_fd); |
| } |
| |
| constexpr char kSkipBlockDevPath[] = "class/skip-block/"; |
| |
| zx_status_t OpenSkipBlockPartition(const fbl::unique_fd& devfs_root, const uint8_t* type_guid, |
| zx_duration_t timeout, fbl::unique_fd* out_fd) { |
| ZX_ASSERT(type_guid); |
| |
| auto cb = [&](const fbl::unique_fd& fd) { |
| fzl::UnownedFdioCaller caller(fd.get()); |
| |
| zx_status_t status; |
| fuchsia_hardware_skipblock_PartitionInfo info; |
| fuchsia_hardware_skipblock_SkipBlockGetPartitionInfo(caller.borrow_channel(), &status, |
| &info); |
| if (status != ZX_OK || memcmp(info.partition_guid, type_guid, GUID_LEN) != 0) { |
| return true; |
| } |
| return false; |
| }; |
| |
| return OpenPartition(devfs_root, kSkipBlockDevPath, cb, timeout, out_fd); |
| } |
| |
| bool HasSkipBlockDevice(const fbl::unique_fd& devfs_root) { |
| // Our proxy for detected a skip-block device is by checking for the |
| // existence of a device enumerated under the skip-block class. |
| const uint8_t type[GPT_GUID_LEN] = GUID_ZIRCON_A_VALUE; |
| return OpenSkipBlockPartition(devfs_root, type, ZX_SEC(1), nullptr) == ZX_OK; |
| } |
| |
| // Attempts to open and overwrite the first block of the underlying |
| // partition. Does not rebind partition drivers. |
| // |
| // At most one of |unique_guid| and |type_guid| may be nullptr. |
| zx_status_t WipeBlockPartition(const fbl::unique_fd& devfs_root, const uint8_t* unique_guid, |
| const uint8_t* type_guid) { |
| zx_status_t status = ZX_OK; |
| fbl::unique_fd fd; |
| if ((status = OpenBlockPartition(devfs_root, unique_guid, type_guid, ZX_SEC(3), &fd)) != ZX_OK) { |
| ERROR("Warning: Could not open partition to wipe: %s\n", |
| zx_status_get_string(status)); |
| return status; |
| } |
| |
| fzl::UnownedFdioCaller caller(fd.get()); |
| fuchsia_hardware_block_BlockInfo info; |
| zx_status_t io_status = fuchsia_hardware_block_BlockGetInfo(caller.borrow_channel(), &status, |
| &info); |
| if (io_status != ZX_OK) { |
| status = io_status; |
| } |
| if (status != ZX_OK) { |
| ERROR("Warning: Could not acquire block info: %s\n", zx_status_get_string(status)); |
| return status; |
| } |
| |
| // Overwrite the first block to (hackily) ensure the destroyed partition |
| // doesn't "reappear" in place. |
| char buf[info.block_size]; |
| memset(buf, 0, info.block_size); |
| |
| if (pwrite(fd.get(), buf, info.block_size, 0) != info.block_size) { |
| ERROR("Warning: Could not write to block device: %s\n", strerror(errno)); |
| return ZX_ERR_IO; |
| } |
| |
| if ((status = FlushBlockDevice(fd)) != ZX_OK) { |
| ERROR("Warning: Failed to synchronize block device: %s\n", |
| zx_status_get_string(status)); |
| return status; |
| } |
| |
| return ZX_OK; |
| } |
| |
| } // namespace |
| |
| const char* PartitionName(Partition type) { |
| switch (type) { |
| case Partition::kBootloader: |
| return "Bootloader"; |
| case Partition::kZirconA: |
| return "Zircon A"; |
| case Partition::kZirconB: |
| return "Zircon B"; |
| case Partition::kZirconR: |
| return "Zircon R"; |
| case Partition::kVbMetaA: |
| return "VBMeta A"; |
| case Partition::kVbMetaB: |
| return "VBMeta B"; |
| case Partition::kVbMetaR: |
| return "VBMeta R"; |
| case Partition::kFuchsiaVolumeManager: |
| return "Fuchsia Volume Manager"; |
| default: |
| return "Unknown"; |
| } |
| } |
| |
| fbl::unique_ptr<DevicePartitioner> DevicePartitioner::Create(fbl::unique_fd devfs_root, |
| zx::channel sysinfo, Arch arch) { |
| // TODO(surajmalhotra): Only use injected devfs_root for skip-block until |
| // ramdisks spawn in isolated devmgr. |
| fbl::unique_fd block_devfs_root((open("/dev", O_RDONLY))); |
| fbl::unique_ptr<DevicePartitioner> device_partitioner; |
| if ((SkipBlockDevicePartitioner::Initialize(std::move(devfs_root), |
| &device_partitioner) == ZX_OK) || |
| (CrosDevicePartitioner::Initialize(block_devfs_root.duplicate(), sysinfo, arch, |
| &device_partitioner) == ZX_OK) || |
| (EfiDevicePartitioner::Initialize(block_devfs_root.duplicate(), sysinfo, arch, |
| &device_partitioner) == ZX_OK) || |
| (FixedDevicePartitioner::Initialize(std::move(block_devfs_root), |
| &device_partitioner) == ZX_OK)) { |
| return device_partitioner; |
| } |
| return nullptr; |
| } |
| |
| /*====================================================* |
| * GPT Common * |
| *====================================================*/ |
| |
| bool GptDevicePartitioner::FindTargetGptPath(const fbl::unique_fd& devfs_root, fbl::String* out) { |
| fbl::unique_fd d_fd(openat(devfs_root.get(), kBlockDevPath, O_RDONLY)); |
| if (!d_fd) { |
| ERROR("Cannot inspect block devices\n"); |
| return false; |
| } |
| DIR* d = fdopendir(d_fd.release()); |
| if (d == nullptr) { |
| ERROR("Cannot inspect block devices\n"); |
| return false; |
| } |
| const auto closer = fbl::MakeAutoCall([&]() { closedir(d); }); |
| |
| struct dirent* de; |
| while ((de = readdir(d)) != nullptr) { |
| fbl::unique_fd fd(openat(dirfd(d), de->d_name, O_RDWR)); |
| if (!fd) { |
| continue; |
| } |
| out->Set(PATH_MAX, '\0'); |
| |
| if (TestBlockFilter && TestBlockFilter(fd)) { |
| continue; |
| } |
| |
| zx::channel dev; |
| zx_status_t status = fdio_get_service_handle(fd.release(), dev.reset_and_get_address()); |
| |
| fuchsia_hardware_block_BlockInfo info; |
| |
| zx_status_t io_status = fuchsia_hardware_block_BlockGetInfo(dev.get(), |
| &status, &info); |
| if (io_status != ZX_OK || status != ZX_OK) { |
| continue; |
| } |
| size_t path_len; |
| char* data = const_cast<char*>(out->data()); |
| io_status = fuchsia_device_ControllerGetTopologicalPath(dev.get(), &status, data, |
| PATH_MAX - 1, &path_len); |
| if (io_status != ZX_OK || status != ZX_OK) { |
| continue; |
| } |
| data[path_len] = 0; |
| |
| // TODO(ZX-1344): This is a hack, but practically, will work for our |
| // usage. |
| // |
| // The GPT which will contain an FVM should be the first non-removable |
| // block device that isn't a partition itself. |
| if (!(info.flags & BLOCK_FLAG_REMOVABLE) && strstr(out->c_str(), "part-") == nullptr) { |
| return true; |
| } |
| } |
| |
| ERROR("No candidate GPT found\n"); |
| return false; |
| } |
| |
| zx_status_t GptDevicePartitioner::InitializeGpt(fbl::unique_fd devfs_root, |
| const zx::channel& sysinfo, |
| Arch arch, |
| fbl::unique_ptr<GptDevicePartitioner>* gpt_out) { |
| if (arch != Arch::kX64) { |
| return ZX_ERR_NOT_FOUND; |
| } |
| |
| fbl::String gpt_path; |
| if (!FindTargetGptPath(devfs_root, &gpt_path)) { |
| ERROR("Failed to find GPT\n"); |
| return ZX_ERR_NOT_FOUND; |
| } |
| fbl::unique_fd fd(open(gpt_path.c_str(), O_RDWR)); |
| if (!fd) { |
| ERROR("Failed to open GPT\n"); |
| return ZX_ERR_NOT_FOUND; |
| } |
| |
| fzl::UnownedFdioCaller caller(fd.get()); |
| fuchsia_hardware_block_BlockInfo block_info; |
| zx_status_t status; |
| zx_status_t io_status = fuchsia_hardware_block_BlockGetInfo(caller.borrow_channel(), &status, |
| &block_info); |
| if (io_status != ZX_OK) { |
| status = io_status; |
| } |
| if (status != ZX_OK) { |
| ERROR("Warning: Could not acquire GPT block info: %s\n", zx_status_get_string(status)); |
| return status; |
| } |
| |
| fbl::unique_ptr<GptDevice> gpt; |
| if (GptDevice::Create(fd.get(), block_info.block_size, block_info.block_count, &gpt) != ZX_OK) { |
| ERROR("Failed to get GPT info\n"); |
| return ZX_ERR_BAD_STATE; |
| } |
| |
| if (!gpt->Valid()) { |
| ERROR("Located GPT is invalid; Attempting to initialize\n"); |
| if (gpt->RemoveAllPartitions() != ZX_OK) { |
| ERROR("Failed to create empty GPT\n"); |
| return ZX_ERR_BAD_STATE; |
| } |
| if (gpt->Sync() != ZX_OK) { |
| ERROR("Failed to sync empty GPT\n"); |
| return ZX_ERR_BAD_STATE; |
| } |
| // Try to rebind the GPT, in case a prior GPT driver was actually |
| // up and running. |
| io_status = fuchsia_hardware_block_BlockRebindDevice(caller.borrow_channel(), &status); |
| if (io_status != ZX_OK) { |
| status = io_status; |
| } |
| if (status != ZX_OK) { |
| ERROR("Failed to re-read GPT\n"); |
| return ZX_ERR_BAD_STATE; |
| } |
| |
| // Manually re-bind the GPT driver, since it is almost certainly |
| // too late to be noticed by the block watcher. |
| io_status = fuchsia_device_ControllerBind( |
| caller.borrow_channel(), kGptDriverName, strlen(kGptDriverName), |
| &status); |
| if (io_status != ZX_OK || status != ZX_OK) { |
| ERROR("Failed to bind GPT\n"); |
| return ZX_ERR_BAD_STATE; |
| } |
| } |
| |
| *gpt_out = WrapUnique(new GptDevicePartitioner(std::move(devfs_root), std::move(fd), |
| std::move(gpt), block_info)); |
| return ZX_OK; |
| } |
| |
| struct PartitionPosition { |
| size_t start; // Block, inclusive |
| size_t length; // In Blocks |
| }; |
| |
| zx_status_t GptDevicePartitioner::FindFirstFit(size_t bytes_requested, size_t* start_out, |
| size_t* length_out) const { |
| LOG("Looking for space\n"); |
| // Gather GPT-related information. |
| size_t blocks_requested = |
| (bytes_requested + block_info_.block_size - 1) / block_info_.block_size; |
| |
| // Sort all partitions by starting block. |
| // For simplicity, include the 'start' and 'end' reserved spots as |
| // partitions. |
| size_t partition_count = 0; |
| PartitionPosition partitions[gpt::kPartitionCount + 2]; |
| const size_t reserved_blocks = ReservedHeaderBlocks(block_info_.block_size); |
| partitions[partition_count].start = 0; |
| partitions[partition_count++].length = reserved_blocks; |
| partitions[partition_count].start = block_info_.block_count - reserved_blocks; |
| partitions[partition_count++].length = reserved_blocks; |
| |
| for (uint32_t i = 0; i < gpt::kPartitionCount; i++) { |
| const gpt_partition_t* p = gpt_->GetPartition(i); |
| if (!p) { |
| continue; |
| } |
| partitions[partition_count].start = p->first; |
| partitions[partition_count].length = p->last - p->first + 1; |
| LOG("Partition seen with start %zu, end %zu (length %zu)\n", p->first, p->last, |
| partitions[partition_count].length); |
| partition_count++; |
| } |
| LOG("Sorting\n"); |
| qsort(partitions, partition_count, sizeof(PartitionPosition), |
| [](const void* p1, const void* p2) { |
| ssize_t s1 = static_cast<ssize_t>(static_cast<const PartitionPosition*>(p1)->start); |
| ssize_t s2 = static_cast<ssize_t>(static_cast<const PartitionPosition*>(p2)->start); |
| return static_cast<int>(s1 - s2); |
| }); |
| |
| // Look for space between the partitions. Since the reserved spots of the |
| // GPT were included in |partitions|, all available space will be located |
| // "between" partitions. |
| for (size_t i = 0; i < partition_count - 1; i++) { |
| const size_t next = partitions[i].start + partitions[i].length; |
| LOG("Partition[%zu] From Block [%zu, %zu) ... (next partition starts at block %zu)\n", |
| i, partitions[i].start, next, partitions[i + 1].start); |
| |
| if (next > partitions[i + 1].start) { |
| ERROR("Corrupted GPT\n"); |
| return ZX_ERR_IO; |
| } |
| const size_t free_blocks = partitions[i + 1].start - next; |
| LOG(" There are %zu free blocks (%zu requested)\n", free_blocks, blocks_requested); |
| if (free_blocks >= blocks_requested) { |
| *start_out = next; |
| *length_out = free_blocks; |
| return ZX_OK; |
| } |
| } |
| ERROR("No GPT space found\n"); |
| return ZX_ERR_NO_RESOURCES; |
| } |
| |
| zx_status_t GptDevicePartitioner::CreateGptPartition(const char* name, uint8_t* type, |
| uint64_t offset, uint64_t blocks, |
| uint8_t* out_guid) const { |
| zx_cprng_draw(out_guid, GPT_GUID_LEN); |
| |
| zx_status_t status; |
| if ((status = gpt_->AddPartition(name, type, out_guid, offset, blocks, 0)) != ZX_OK) { |
| ERROR("Failed to add partition\n"); |
| return ZX_ERR_IO; |
| } |
| if ((status = gpt_->Sync()) != ZX_OK) { |
| ERROR("Failed to sync GPT\n"); |
| return ZX_ERR_IO; |
| } |
| if ((status = gpt_->ClearPartition(offset, 1)) != ZX_OK) { |
| ERROR("Failed to clear first block of new partition\n"); |
| return status; |
| } |
| zx_status_t io_status = fuchsia_hardware_block_BlockRebindDevice(Channel()->get(), &status); |
| if (io_status != ZX_OK) { |
| status = io_status; |
| } |
| if (status != ZX_OK) { |
| ERROR("Failed to rebind GPT\n"); |
| return status; |
| } |
| |
| return ZX_OK; |
| } |
| |
| zx_status_t GptDevicePartitioner::AddPartition( |
| const char* name, uint8_t* type, size_t minimum_size_bytes, |
| size_t optional_reserve_bytes, fbl::unique_fd* out_fd) const { |
| |
| uint64_t start, length; |
| zx_status_t status; |
| if ((status = FindFirstFit(minimum_size_bytes, &start, &length)) != ZX_OK) { |
| ERROR("Couldn't find fit\n"); |
| return status; |
| } |
| LOG("Found space in GPT - OK %zu @ %zu\n", length, start); |
| |
| if (optional_reserve_bytes) { |
| // If we can fulfill the requested size, and we still have space for the |
| // optional reserve section, then we should shorten the amount of blocks |
| // we're asking for. |
| // |
| // This isn't necessary, but it allows growing the GPT later, if necessary. |
| const size_t optional_reserve_blocks = optional_reserve_bytes / block_info_.block_size; |
| if (length - optional_reserve_bytes > (minimum_size_bytes / block_info_.block_size)) { |
| LOG("Space for reserve - OK\n"); |
| length -= optional_reserve_blocks; |
| } |
| } else { |
| length = fbl::round_up(minimum_size_bytes, block_info_.block_size) / block_info_.block_size; |
| } |
| LOG("Final space in GPT - OK %zu @ %zu\n", length, start); |
| |
| uint8_t guid[GPT_GUID_LEN]; |
| if ((status = CreateGptPartition(name, type, start, length, guid)) != ZX_OK) { |
| return status; |
| } |
| LOG("Added partition, waiting for bind\n"); |
| |
| if ((status = OpenBlockPartition(devfs_root_, guid, type, ZX_SEC(5), out_fd)) != ZX_OK) { |
| ERROR("Added partition, waiting for bind - NOT FOUND\n"); |
| return status; |
| } |
| LOG("Added partition, waiting for bind - OK\n"); |
| return ZX_OK; |
| } |
| |
| zx_status_t GptDevicePartitioner::FindPartition(FilterCallback filter, gpt_partition_t** out, |
| fbl::unique_fd* out_fd) const { |
| for (uint32_t i = 0; i < gpt::kPartitionCount; i++) { |
| gpt_partition_t* p = gpt_->GetPartition(i); |
| if (!p) { |
| continue; |
| } |
| |
| if (filter(*p)) { |
| LOG("Found partition in GPT, partition %u\n", i); |
| if (out) { |
| *out = p; |
| } |
| if (out_fd) { |
| zx_status_t status; |
| status = OpenBlockPartition(devfs_root_, p->guid, p->type, ZX_SEC(5), out_fd); |
| if (status != ZX_OK) { |
| ERROR("Couldn't open partition\n"); |
| return status; |
| } |
| } |
| return ZX_OK; |
| } |
| } |
| return ZX_ERR_NOT_FOUND; |
| } |
| |
| zx_status_t GptDevicePartitioner::FindPartition(FilterCallback filter, |
| fbl::unique_fd* out_fd) const { |
| for (uint32_t i = 0; i < gpt::kPartitionCount; i++) { |
| const gpt_partition_t* p = gpt_->GetPartition(i); |
| if (!p) { |
| continue; |
| } |
| |
| if (filter(*p)) { |
| LOG("Found partition in GPT, partition %u\n", i); |
| if (out_fd) { |
| zx_status_t status; |
| status = OpenBlockPartition(devfs_root_, p->guid, p->type, ZX_SEC(5), out_fd); |
| if (status != ZX_OK) { |
| ERROR("Couldn't open partition\n"); |
| return status; |
| } |
| } |
| return ZX_OK; |
| } |
| } |
| return ZX_ERR_NOT_FOUND; |
| } |
| |
| zx_status_t GptDevicePartitioner::WipeFvm() const { |
| bool modify = false; |
| for (uint32_t i = 0; i < gpt::kPartitionCount; i++) { |
| const gpt_partition_t* p = gpt_->GetPartition(i); |
| if (!p) { |
| continue; |
| } |
| if (!IsFvmPartition(*p)) { |
| continue; |
| } |
| |
| modify = true; |
| |
| // Ignore the return status; wiping is a best-effort approach anyway. |
| WipeBlockPartition(devfs_root_, p->guid, p->type); |
| |
| if (gpt_->RemovePartition(p->guid) != ZX_OK) { |
| ERROR("Warning: Could not remove partition\n"); |
| } else { |
| // If we successfully clear the partition, then all subsequent |
| // partitions get shifted down. If we just deleted partition 'i', |
| // we now need to look at partition 'i' again, since it's now |
| // occupied by what was in 'i+1'. |
| i--; |
| } |
| } |
| if (modify) { |
| gpt_->Sync(); |
| LOG("Immediate reboot strongly recommended\n"); |
| } |
| zx_status_t status; |
| fuchsia_hardware_block_BlockRebindDevice(Channel()->get(), &status); |
| return ZX_OK; |
| } |
| |
| /*====================================================* |
| * EFI SPECIFIC * |
| *====================================================*/ |
| |
| zx_status_t EfiDevicePartitioner::Initialize(fbl::unique_fd devfs_root, const zx::channel& sysinfo, |
| Arch arch, |
| fbl::unique_ptr<DevicePartitioner>* partitioner) { |
| fbl::unique_ptr<GptDevicePartitioner> gpt; |
| zx_status_t status = GptDevicePartitioner::InitializeGpt(std::move(devfs_root), sysinfo, arch, |
| &gpt); |
| if (status != ZX_OK) { |
| return status; |
| } |
| if (is_cros(gpt->GetGpt())) { |
| ERROR("Use CrOS Device Partitioner."); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| LOG("Successfully initialized EFI Device Partitioner\n"); |
| *partitioner = WrapUnique(new EfiDevicePartitioner(std::move(gpt))); |
| return ZX_OK; |
| } |
| |
| zx_status_t EfiDevicePartitioner::AddPartition(Partition partition_type, |
| fbl::unique_fd* out_fd) const { |
| const char* name; |
| uint8_t type[GPT_GUID_LEN]; |
| size_t minimum_size_bytes = 0; |
| size_t optional_reserve_bytes = 0; |
| |
| switch (partition_type) { |
| case Partition::kBootloader: { |
| const uint8_t efi_type[GPT_GUID_LEN] = GUID_EFI_VALUE; |
| memcpy(type, efi_type, GPT_GUID_LEN); |
| minimum_size_bytes = 20LU * (1 << 20); |
| name = kEfiName; |
| break; |
| } |
| case Partition::kZirconA: { |
| const uint8_t zircon_a_type[GPT_GUID_LEN] = GUID_ZIRCON_A_VALUE; |
| memcpy(type, zircon_a_type, GPT_GUID_LEN); |
| minimum_size_bytes = 16LU * (1 << 20); |
| name = kZirconAName; |
| break; |
| } |
| case Partition::kZirconB: { |
| const uint8_t zircon_b_type[GPT_GUID_LEN] = GUID_ZIRCON_B_VALUE; |
| memcpy(type, zircon_b_type, GPT_GUID_LEN); |
| minimum_size_bytes = 16LU * (1 << 20); |
| name = kZirconBName; |
| break; |
| } |
| case Partition::kZirconR: { |
| const uint8_t zircon_r_type[GPT_GUID_LEN] = GUID_ZIRCON_R_VALUE; |
| memcpy(type, zircon_r_type, GPT_GUID_LEN); |
| minimum_size_bytes = 24LU * (1 << 20); |
| name = kZirconRName; |
| break; |
| } |
| case Partition::kFuchsiaVolumeManager: { |
| const uint8_t fvm_type[GPT_GUID_LEN] = GUID_FVM_VALUE; |
| memcpy(type, fvm_type, GPT_GUID_LEN); |
| minimum_size_bytes = 8LU * (1 << 30); |
| name = kFvmPartitionName; |
| break; |
| } |
| default: |
| ERROR("EFI partitioner cannot add unknown partition type\n"); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| return gpt_->AddPartition(name, type, minimum_size_bytes, |
| optional_reserve_bytes, out_fd); |
| } |
| |
| zx_status_t EfiDevicePartitioner::FindPartition(Partition partition_type, |
| fbl::unique_fd* out_fd) const { |
| switch (partition_type) { |
| case Partition::kBootloader: { |
| return gpt_->FindPartition(IsGigabootPartition, out_fd); |
| } |
| case Partition::kZirconA: { |
| const auto filter = [](const gpt_partition_t& part) { |
| const uint8_t guid[GPT_GUID_LEN] = GUID_ZIRCON_A_VALUE; |
| return KernelFilterCallback(part, guid, kZirconAName); |
| }; |
| return gpt_->FindPartition(filter, out_fd); |
| } |
| case Partition::kZirconB: { |
| const auto filter = [](const gpt_partition_t& part) { |
| const uint8_t guid[GPT_GUID_LEN] = GUID_ZIRCON_B_VALUE; |
| return KernelFilterCallback(part, guid, kZirconBName); |
| }; |
| return gpt_->FindPartition(filter, out_fd); |
| } |
| case Partition::kZirconR: { |
| const auto filter = [](const gpt_partition_t& part) { |
| const uint8_t guid[GPT_GUID_LEN] = GUID_ZIRCON_R_VALUE; |
| return KernelFilterCallback(part, guid, kZirconRName); |
| }; |
| return gpt_->FindPartition(filter, out_fd); |
| } |
| case Partition::kFuchsiaVolumeManager: |
| return gpt_->FindPartition(IsFvmPartition, out_fd); |
| |
| default: |
| ERROR("EFI partitioner cannot find unknown partition type\n"); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| } |
| |
| zx_status_t EfiDevicePartitioner::WipeFvm() const { |
| return gpt_->WipeFvm(); |
| } |
| |
| zx_status_t EfiDevicePartitioner::GetBlockSize(const fbl::unique_fd& device_fd, |
| uint32_t* block_size) const { |
| fuchsia_hardware_block_BlockInfo info; |
| zx_status_t status = gpt_->GetBlockInfo(&info); |
| if (status == ZX_OK) { |
| *block_size = info.block_size; |
| } |
| return status; |
| } |
| |
| /*====================================================* |
| * CROS SPECIFIC * |
| *====================================================*/ |
| |
| zx_status_t CrosDevicePartitioner::Initialize(fbl::unique_fd devfs_root, const zx::channel& sysinfo, |
| Arch arch, |
| fbl::unique_ptr<DevicePartitioner>* partitioner) { |
| fbl::unique_ptr<GptDevicePartitioner> gpt_partitioner; |
| zx_status_t status = GptDevicePartitioner::InitializeGpt(std::move(devfs_root), sysinfo, arch, |
| &gpt_partitioner); |
| if (status != ZX_OK) { |
| return status; |
| } |
| |
| GptDevice* gpt = gpt_partitioner->GetGpt(); |
| if (!is_cros(gpt)) { |
| return ZX_ERR_NOT_FOUND; |
| } |
| |
| fuchsia_hardware_block_BlockInfo info; |
| gpt_partitioner->GetBlockInfo(&info); |
| |
| if (!is_ready_to_pave(gpt, &info, SZ_ZX_PART)) { |
| if ((status = config_cros_for_fuchsia(gpt, &info, SZ_ZX_PART)) != ZX_OK) { |
| ERROR("Failed to configure CrOS for Fuchsia.\n"); |
| return status; |
| } |
| if ((status = gpt->Sync()) != ZX_OK) { |
| ERROR("Failed to sync CrOS for Fuchsia.\n"); |
| return status; |
| } |
| fuchsia_hardware_block_BlockRebindDevice(gpt_partitioner->Channel()->get(), &status); |
| } |
| |
| LOG("Successfully initialized CrOS Device Partitioner\n"); |
| *partitioner = WrapUnique(new CrosDevicePartitioner(std::move(gpt_partitioner))); |
| return ZX_OK; |
| } |
| |
| zx_status_t CrosDevicePartitioner::AddPartition(Partition partition_type, |
| fbl::unique_fd* out_fd) const { |
| const char* name; |
| uint8_t type[GPT_GUID_LEN]; |
| size_t minimum_size_bytes = 0; |
| size_t optional_reserve_bytes = 0; |
| |
| switch (partition_type) { |
| case Partition::kZirconA: { |
| const uint8_t kernc_type[GPT_GUID_LEN] = GUID_CROS_KERNEL_VALUE; |
| memcpy(type, kernc_type, GPT_GUID_LEN); |
| minimum_size_bytes = 64LU * (1 << 20); |
| name = kZirconAName; |
| break; |
| } |
| case Partition::kZirconR: { |
| const uint8_t zircon_r_type[GPT_GUID_LEN] = GUID_ZIRCON_R_VALUE; |
| memcpy(type, zircon_r_type, GPT_GUID_LEN); |
| minimum_size_bytes = 24LU * (1 << 20); |
| name = kZirconRName; |
| break; |
| } |
| case Partition::kFuchsiaVolumeManager: { |
| const uint8_t fvm_type[GPT_GUID_LEN] = GUID_FVM_VALUE; |
| memcpy(type, fvm_type, GPT_GUID_LEN); |
| minimum_size_bytes = 8LU * (1 << 30); |
| name = kFvmPartitionName; |
| break; |
| } |
| default: |
| ERROR("Cros partitioner cannot add unknown partition type\n"); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| return gpt_->AddPartition(name, type, minimum_size_bytes, |
| optional_reserve_bytes, out_fd); |
| } |
| |
| zx_status_t CrosDevicePartitioner::FindPartition(Partition partition_type, |
| fbl::unique_fd* out_fd) const { |
| switch (partition_type) { |
| case Partition::kZirconA: { |
| const auto filter = [](const gpt_partition_t& part) { |
| const uint8_t guid[GPT_GUID_LEN] = GUID_CROS_KERNEL_VALUE; |
| return KernelFilterCallback(part, guid, kZirconAName); |
| }; |
| return gpt_->FindPartition(filter, out_fd); |
| } |
| case Partition::kZirconR: { |
| const auto filter = [](const gpt_partition_t& part) { |
| const uint8_t guid[GPT_GUID_LEN] = GUID_ZIRCON_R_VALUE; |
| return KernelFilterCallback(part, guid, kZirconRName); |
| }; |
| return gpt_->FindPartition(filter, out_fd); |
| } |
| case Partition::kFuchsiaVolumeManager: |
| return gpt_->FindPartition(IsFvmPartition, out_fd); |
| |
| default: |
| ERROR("Cros partitioner cannot find unknown partition type\n"); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| } |
| |
| zx_status_t CrosDevicePartitioner::FinalizePartition(Partition partition_type) const { |
| // Special partition finalization is only necessary for Zircon partitions. |
| if (partition_type != Partition::kZirconA) { |
| return ZX_OK; |
| } |
| |
| uint8_t top_priority = 0; |
| |
| const uint8_t kern_type[GPT_GUID_LEN] = GUID_CROS_KERNEL_VALUE; |
| constexpr char kPrefix[] = "ZIRCON-"; |
| uint16_t zircon_prefix[strlen(kPrefix) * 2]; |
| cstring_to_utf16(&zircon_prefix[0], kPrefix, strlen(kPrefix)); |
| |
| for (uint32_t i = 0; i < gpt::kPartitionCount; ++i) { |
| const gpt_partition_t* part = gpt_->GetGpt()->GetPartition(i); |
| if (part == NULL) { |
| continue; |
| } |
| if (memcmp(part->type, kern_type, GPT_GUID_LEN)) { |
| continue; |
| } |
| if (memcmp(part->name, zircon_prefix, strlen(kPrefix) * 2)) { |
| const uint8_t priority = gpt_cros_attr_get_priority(part->flags); |
| if (priority > top_priority) { |
| top_priority = priority; |
| } |
| } |
| } |
| |
| const auto filter_zircona = [](const gpt_partition_t& part) { |
| const uint8_t guid[GPT_GUID_LEN] = GUID_CROS_KERNEL_VALUE; |
| return KernelFilterCallback(part, guid, kZirconAName); |
| }; |
| zx_status_t status; |
| gpt_partition_t* partition; |
| if ((status = gpt_->FindPartition(filter_zircona, &partition, nullptr)) != ZX_OK) { |
| ERROR("Cannot find %s partition\n", kZirconAName); |
| return status; |
| } |
| |
| // Priority for Zircon A set to higher priority than all other kernels. |
| if (top_priority == UINT8_MAX) { |
| ERROR("Cannot set CrOS partition priority higher than other kernels\n"); |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| |
| // TODO(raggi): when other (B/R) partitions are paved, set their priority |
| // appropriately as well. |
| |
| if (gpt_cros_attr_set_priority(&partition->flags, ++top_priority) != 0) { |
| ERROR("Cannot set CrOS partition priority for ZIRCON-A\n"); |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| // Successful set to 'true' to encourage the bootloader to |
| // use this partition. |
| gpt_cros_attr_set_successful(&partition->flags, true); |
| // Maximize the number of attempts to boot this partition before |
| // we fall back to a different kernel. |
| if (gpt_cros_attr_set_tries(&partition->flags, 15) != 0) { |
| ERROR("Cannot set CrOS partition 'tries' for KERN-C\n"); |
| return ZX_ERR_OUT_OF_RANGE; |
| } |
| if ((status = gpt_->GetGpt()->Sync()) == ZX_OK) { |
| ERROR("Failed to sync CrOS partition 'tries' for KERN-C.\n"); |
| return status; |
| } |
| |
| return ZX_OK; |
| } |
| |
| zx_status_t CrosDevicePartitioner::WipeFvm() const { |
| return gpt_->WipeFvm(); |
| } |
| |
| zx_status_t CrosDevicePartitioner::GetBlockSize(const fbl::unique_fd& device_fd, |
| uint32_t* block_size) const { |
| fuchsia_hardware_block_BlockInfo info; |
| zx_status_t status = gpt_->GetBlockInfo(&info); |
| if (status == ZX_OK) { |
| *block_size = info.block_size; |
| } |
| return status; |
| } |
| |
| /*====================================================* |
| * FIXED PARTITION MAP * |
| *====================================================*/ |
| |
| zx_status_t FixedDevicePartitioner::Initialize(fbl::unique_fd devfs_root, |
| fbl::unique_ptr<DevicePartitioner>* partitioner) { |
| if (HasSkipBlockDevice(devfs_root)) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| LOG("Successfully initialized FixedDevicePartitioner Device Partitioner\n"); |
| *partitioner = WrapUnique(new FixedDevicePartitioner(std::move(devfs_root))); |
| return ZX_OK; |
| } |
| |
| zx_status_t FixedDevicePartitioner::AddPartition(Partition partition_type, |
| fbl::unique_fd* out_fd) const { |
| ERROR("Cannot add partitions to a fixed-map partition device\n"); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| zx_status_t FixedDevicePartitioner::FindPartition(Partition partition_type, |
| fbl::unique_fd* out_fd) const { |
| uint8_t type[GPT_GUID_LEN]; |
| |
| switch (partition_type) { |
| case Partition::kZirconA: { |
| const uint8_t zircon_a_type[GPT_GUID_LEN] = GUID_ZIRCON_A_VALUE; |
| memcpy(type, zircon_a_type, GPT_GUID_LEN); |
| break; |
| } |
| case Partition::kZirconB: { |
| const uint8_t zircon_b_type[GPT_GUID_LEN] = GUID_ZIRCON_B_VALUE; |
| memcpy(type, zircon_b_type, GPT_GUID_LEN); |
| break; |
| } |
| case Partition::kZirconR: { |
| const uint8_t zircon_r_type[GPT_GUID_LEN] = GUID_ZIRCON_R_VALUE; |
| memcpy(type, zircon_r_type, GPT_GUID_LEN); |
| break; |
| } |
| case Partition::kVbMetaA: { |
| const uint8_t vbmeta_a_type[GPT_GUID_LEN] = GUID_VBMETA_A_VALUE; |
| memcpy(type, vbmeta_a_type, GPT_GUID_LEN); |
| break; |
| } |
| case Partition::kVbMetaB: { |
| const uint8_t vbmeta_b_type[GPT_GUID_LEN] = GUID_VBMETA_B_VALUE; |
| memcpy(type, vbmeta_b_type, GPT_GUID_LEN); |
| break; |
| } |
| case Partition::kVbMetaR: { |
| const uint8_t vbmeta_r_type[GPT_GUID_LEN] = GUID_VBMETA_R_VALUE; |
| memcpy(type, vbmeta_r_type, GPT_GUID_LEN); |
| break; |
| } |
| case Partition::kFuchsiaVolumeManager: { |
| const uint8_t fvm_type[GPT_GUID_LEN] = GUID_FVM_VALUE; |
| memcpy(type, fvm_type, GPT_GUID_LEN); |
| break; |
| } |
| default: |
| ERROR("partition_type is invalid!\n"); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| return OpenBlockPartition(devfs_root_, nullptr, type, ZX_SEC(5), out_fd); |
| } |
| |
| zx_status_t FixedDevicePartitioner::WipeFvm() const { |
| const uint8_t fvm_type[GPT_GUID_LEN] = GUID_FVM_VALUE; |
| zx_status_t status; |
| if ((status = WipeBlockPartition(devfs_root_, nullptr, fvm_type)) != ZX_OK) { |
| ERROR("Failed to wipe FVM.\n"); |
| } else { |
| LOG("Wiped FVM successfully.\n"); |
| } |
| LOG("Immediate reboot strongly recommended\n"); |
| return ZX_OK; |
| } |
| |
| zx_status_t FixedDevicePartitioner::GetBlockSize(const fbl::unique_fd& device_fd, |
| uint32_t* block_size) const { |
| fzl::UnownedFdioCaller caller(device_fd.get()); |
| fuchsia_hardware_block_BlockInfo block_info; |
| |
| zx_status_t status; |
| zx_status_t io_status = fuchsia_hardware_block_BlockGetInfo(caller.borrow_channel(), &status, |
| &block_info); |
| if (io_status != ZX_OK) { |
| status = io_status; |
| } |
| if (status != ZX_OK) { |
| return status; |
| } |
| *block_size = block_info.block_size; |
| return ZX_OK; |
| } |
| |
| /*====================================================* |
| * SKIP BLOCK SPECIFIC * |
| *====================================================*/ |
| |
| zx_status_t SkipBlockDevicePartitioner::Initialize( |
| fbl::unique_fd devfs_root, fbl::unique_ptr<DevicePartitioner>* partitioner) { |
| |
| // TODO(surajmalhtora): Use common devfs_root fd for both block and |
| // skip-block devices. |
| fbl::unique_fd block_devfs_root(open("/dev", O_RDONLY)); |
| |
| if (!HasSkipBlockDevice(devfs_root)) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| LOG("Successfully initialized SkipBlockDevicePartitioner Device Partitioner\n"); |
| *partitioner = WrapUnique(new SkipBlockDevicePartitioner(std::move(devfs_root), |
| std::move(block_devfs_root))); |
| return ZX_OK; |
| } |
| |
| zx_status_t SkipBlockDevicePartitioner::AddPartition(Partition partition_type, |
| fbl::unique_fd* out_fd) const { |
| ERROR("Cannot add partitions to a skip-block, fixed partition device\n"); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| zx_status_t SkipBlockDevicePartitioner::FindPartition(Partition partition_type, |
| fbl::unique_fd* out_fd) const { |
| uint8_t type[GPT_GUID_LEN]; |
| |
| switch (partition_type) { |
| case Partition::kBootloader: { |
| const uint8_t bootloader_type[GPT_GUID_LEN] = GUID_BOOTLOADER_VALUE; |
| memcpy(type, bootloader_type, GPT_GUID_LEN); |
| break; |
| } |
| case Partition::kZirconA: { |
| const uint8_t zircon_a_type[GPT_GUID_LEN] = GUID_ZIRCON_A_VALUE; |
| memcpy(type, zircon_a_type, GPT_GUID_LEN); |
| break; |
| } |
| case Partition::kZirconB: { |
| const uint8_t zircon_b_type[GPT_GUID_LEN] = GUID_ZIRCON_B_VALUE; |
| memcpy(type, zircon_b_type, GPT_GUID_LEN); |
| break; |
| } |
| case Partition::kZirconR: { |
| const uint8_t zircon_r_type[GPT_GUID_LEN] = GUID_ZIRCON_R_VALUE; |
| memcpy(type, zircon_r_type, GPT_GUID_LEN); |
| break; |
| } |
| case Partition::kVbMetaA: { |
| const uint8_t vbmeta_a_type[GPT_GUID_LEN] = GUID_VBMETA_A_VALUE; |
| memcpy(type, vbmeta_a_type, GPT_GUID_LEN); |
| break; |
| } |
| case Partition::kVbMetaB: { |
| const uint8_t vbmeta_b_type[GPT_GUID_LEN] = GUID_VBMETA_B_VALUE; |
| memcpy(type, vbmeta_b_type, GPT_GUID_LEN); |
| break; |
| } |
| case Partition::kVbMetaR: { |
| const uint8_t vbmeta_r_type[GPT_GUID_LEN] = GUID_VBMETA_R_VALUE; |
| memcpy(type, vbmeta_r_type, GPT_GUID_LEN); |
| break; |
| } |
| case Partition::kFuchsiaVolumeManager: { |
| const uint8_t fvm_type[GPT_GUID_LEN] = GUID_FVM_VALUE; |
| memcpy(type, fvm_type, GPT_GUID_LEN); |
| // FVM partition is managed so it should expose a normal block device. |
| return OpenBlockPartition(block_devfs_root_, nullptr, type, ZX_SEC(5), out_fd); |
| } |
| default: |
| ERROR("partition_type is invalid!\n"); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| return OpenSkipBlockPartition(devfs_root_, type, ZX_SEC(5), out_fd); |
| } |
| |
| zx_status_t SkipBlockDevicePartitioner::WipeFvm() const { |
| const uint8_t fvm_type[GPT_GUID_LEN] = GUID_FVM_VALUE; |
| zx_status_t status; |
| fbl::unique_fd block_fd; |
| status = OpenBlockPartition(block_devfs_root_, nullptr, fvm_type, ZX_SEC(3), &block_fd); |
| if (status != ZX_OK) { |
| ERROR("Warning: Could not open partition to wipe: %s\n", zx_status_get_string(status)); |
| return ZX_OK; |
| } |
| |
| zx::channel block_dev; |
| status = fdio_get_service_handle(block_fd.release(), block_dev.reset_and_get_address()); |
| if (status != ZX_OK) { |
| ERROR("Warning: Could not get block service handle: %s\n", zx_status_get_string(status)); |
| return status; |
| } |
| char name[PATH_MAX + 1]; |
| size_t name_len; |
| zx_status_t call_status; |
| status = fuchsia_device_ControllerGetTopologicalPath(block_dev.get(), &call_status, name, |
| sizeof(name) - 1, &name_len); |
| if (status == ZX_OK) { |
| status = call_status; |
| } |
| if (status != ZX_OK) { |
| ERROR("Warning: Could not get name for partition: %s\n", |
| zx_status_get_string(status)); |
| return status; |
| } |
| name[name_len] = 0; |
| |
| const char* parent = dirname(name); |
| |
| fbl::unique_fd parent_fd(open(parent, O_RDONLY)); |
| if (!parent_fd) { |
| ERROR("Warning: Unable to open block parent device.\n"); |
| return ZX_ERR_IO; |
| } |
| |
| zx::channel svc; |
| status = fdio_get_service_handle(parent_fd.release(), svc.reset_and_get_address()); |
| if (status != ZX_OK) { |
| ERROR("Warning: Could not get service handle: %s\n", zx_status_get_string(status)); |
| return status; |
| } |
| zx_status_t status2; |
| status = fuchsia_hardware_block_FtlFormat(svc.get(), &status2); |
| |
| return status == ZX_OK ? status2 : status; |
| } |
| |
| zx_status_t SkipBlockDevicePartitioner::GetBlockSize(const fbl::unique_fd& device_fd, |
| uint32_t* block_size) const { |
| fzl::UnownedFdioCaller caller(device_fd.get()); |
| fuchsia_hardware_block_BlockInfo block_info; |
| |
| // Just in case we are trying to get info about a block-based device. |
| // |
| // Clone ahead of time; if it is NOT a block device, the connection will be terminated. |
| zx::channel maybe_block(fdio_service_clone(caller.borrow_channel())); |
| zx_status_t status; |
| zx_status_t io_status = fuchsia_hardware_block_BlockGetInfo(maybe_block.get(), &status, |
| &block_info); |
| if (io_status == ZX_OK && status == ZX_OK) { |
| *block_size = block_info.block_size; |
| return ZX_OK; |
| } |
| |
| fuchsia_hardware_skipblock_PartitionInfo part_info; |
| io_status = fuchsia_hardware_skipblock_SkipBlockGetPartitionInfo(caller.borrow_channel(), |
| &status, &part_info); |
| if (io_status != ZX_OK) { |
| status = io_status; |
| } |
| if (status != ZX_OK) { |
| ERROR("Failed to get partition info with status: %d\n", status); |
| return status; |
| } |
| *block_size = static_cast<uint32_t>(part_info.block_size_bytes); |
| |
| return ZX_OK; |
| } |
| |
| } // namespace paver |
