zircon/system/ulib/chromeos-disk-setup/chromeos-disk-setup.cc - fuchsia - Git at Google

 // Copyright 2017 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 <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/param.h>
 #include <zircon/assert.h>
 #include <zircon/device/block.h>
 #include <zircon/errors.h>
 #include <zircon/syscalls.h>
 #include <zircon/types.h>

 #include <chromeos-disk-setup/chromeos-disk-setup.h>
 #include <gpt/cros.h>
 #include <gpt/gpt.h>

 namespace chromeos_disk_setup {
 using gpt::GptDevice;
 namespace {

 constexpr uint8_t kFvmGuid[GPT_GUID_LEN] = GUID_FVM_VALUE;
 constexpr uint8_t kKernGuid[GPT_GUID_LEN] = GUID_CROS_KERNEL_VALUE;
 constexpr uint8_t kRootGuid[GPT_GUID_LEN] = GUID_CROS_ROOT_VALUE;
 constexpr uint8_t kStateGuid[GPT_GUID_LEN] = GUID_CROS_STATE_VALUE;
 constexpr uint8_t kSysCfgGuid[GPT_GUID_LEN] = GUID_SYS_CONFIG_VALUE;

 // this value is shared with device-partitioner.cpp
 constexpr uint64_t kMinFvmSize = 8LU * (1 << 30);

 constexpr uint64_t kSysCfgSize = 1 << 20;

 // part_name_eql compares the name field in the given partition to the cstring
 // name, returning true if the partition name is equal to name and zero-padded.
 bool part_name_eql(const gpt_partition_t* part, const char* name) {
   if (part == NULL) {
     return false;
   }
   char buf[GPT_NAME_LEN] = {0};
   utf16_to_cstring(&buf[0], (const uint16_t*)part->name, GPT_NAME_LEN / 2);
   return !strncmp(buf, name, GPT_NAME_LEN);
 }

 // part_name_guid_eql returns true if the given partition has the given name and
 // the given type GUID, false otherwise.
 bool part_name_guid_eql(const gpt_partition_t* part, const char* name,
                         const uint8_t guid[GPT_GUID_LEN]) {
   if (part == NULL) {
     return false;
   }
   if (!memcmp(part->type, &guid[0], GPT_GUID_LEN) && part_name_eql(part, name)) {
     return true;
   }
   return false;
 }

 // part_size_gte returns true if the partition size is greater than or equal to
 // the size given, false otherwise.
 bool part_size_gte(gpt_partition_t* part, uint64_t size, uint64_t block_size) {
   if (part == NULL) {
     return false;
   }
   uint64_t size_in_blocks = part->last - part->first + 1;
   return size_in_blocks * block_size >= size;
 }

 // find_by_type finds the first partition matching the given type guid.
 gpt_partition_t* find_by_type(const GptDevice* gpt, const uint8_t type_guid[GPT_GUID_LEN]) {
   for (uint32_t i = 0; i < gpt::kPartitionCount; ++i) {
     gpt_partition_t* p = gpt->GetPartition(i);
     if (p == NULL) {
       continue;
     }
     if (!memcmp(p->type, &type_guid[0], GPT_GUID_LEN)) {
       return p;
     }
   }
   return NULL;
 }

 // find_by_type_and_name finds the first partition matching the given type guid and name.
 gpt_partition_t* find_by_type_and_name(const GptDevice* gpt, const uint8_t type_guid[GPT_GUID_LEN],
                                        const char* name) {
   for (uint32_t i = 0; i < gpt::kPartitionCount; ++i) {
     gpt_partition_t* p = gpt->GetPartition(i);
     if (p == NULL) {
       continue;
     }
     if (part_name_guid_eql(p, name, type_guid)) {
       return p;
     }
   }
   return NULL;
 }

 // Find a contiguous run of free space on the disk at least blocks_req in length.
 // If space is found, true is returned and out_hole_start and out_hole_end
 // contain the first free and last free blocks in a contiguous run.
 bool find_space(GptDevice* gpt, const uint64_t blocks_req, uint64_t* out_hole_start,
                 uint64_t* out_hole_end) {
   gpt_partition_t* parts[gpt::kPartitionCount] = {0};
   for (uint32_t i = 0; i < gpt::kPartitionCount; i++) {
     parts[i] = gpt->GetPartition(i);
   }

   // XXX(raggi): once the lib supports more and less than gpt::kPartitionCount,
   // this will need to be fixed (as will many loops).
   gpt_sort_partitions(parts, gpt::kPartitionCount);

   uint64_t first_usable, last_usable;
   ZX_ASSERT(gpt->Range(&first_usable, &last_usable) == ZX_OK);

   uint64_t prev_end = first_usable - 1;
   for (uint32_t i = 0; i < gpt::kPartitionCount; i++) {
     if (parts[i] == NULL) {
       continue;
     }

     // TODO(raggi): find out how the tests end up making this state
     if (parts[i]->first >= last_usable || parts[i]->last >= last_usable) {
       break;
     }

     uint64_t gap = parts[i]->first - (prev_end + 1);
     if (gap >= blocks_req) {
       *out_hole_start = prev_end + 1;
       *out_hole_end = parts[i]->first - 1;

       return true;
     }
     prev_end = parts[i]->last;
   }

   if (prev_end < last_usable && last_usable - (prev_end + 1) >= blocks_req) {
     *out_hole_start = prev_end + 1;
     *out_hole_end = last_usable;

     return true;
   }

   return false;
 }

 // create a GPT entry with the supplied attributes and assign it a random
 // GUID. May return an error if the GUID can not be generated for the partition
 // or operations on the gpt_device_t fail.
 zx_status_t create_gpt_entry(GptDevice* gpt, const uint64_t first, const uint64_t blks,
                              const uint8_t type[GPT_GUID_LEN], const char* name) {
   uint8_t guid[GPT_GUID_LEN];
   zx_cprng_draw(guid, GPT_GUID_LEN);

   uint8_t tguid[GPT_GUID_LEN];
   memcpy(&tguid, type, GPT_GUID_LEN);
   if (gpt->AddPartition(name, tguid, guid, first, blks, 0) != ZX_OK) {
     return ZX_ERR_INTERNAL;
   }

   return ZX_OK;
 }

 }  // namespace

 __BEGIN_CDECLS

 bool is_cros(const GptDevice* gpt) {
   uint8_t roots = 0;
   uint8_t kerns = 0;
   bool state = false;

   for (uint32_t i = 0; i < gpt::kPartitionCount; ++i) {
     gpt_partition_t* p = gpt->GetPartition(i);
     if (p == NULL) {
       continue;
     }

     if (!memcmp(p->type, kRootGuid, GPT_GUID_LEN) &&
         (part_name_eql(p, "ROOT-A") || part_name_eql(p, "ROOT-B"))) {
       roots++;
     } else if (!memcmp(p->type, kKernGuid, GPT_GUID_LEN) &&
                (part_name_eql(p, "KERN-A") || part_name_eql(p, "KERN-B"))) {
       kerns++;
     } else if (!memcmp(p->type, kStateGuid, GPT_GUID_LEN) && part_name_eql(p, "STATE")) {
       state = true;
     }
   }

   return state && roots >= 2 && kerns >= 2;
 }

 // is_ready_to_pave returns true if there exist partitions for:
 // * ZIRCON-A is a GUID_CROS_KERNEL_VALUE at least sz_kern in size.
 // * ZIRCON-B is a GUID_CROS_KERNEL_VALUE at least sz_kern in size.
 // * ZIRCON-R is a GUID_CROS_KERNEL_VALUE at least sz_kern in size.
 // * FVM      is a GUID_FVM_VALUE         at least sz_kern * 8 in size
 bool is_ready_to_pave(const GptDevice* gpt, const fuchsia_hardware_block_BlockInfo* blk_info,
                       const uint64_t sz_kern) {
   bool found_zircon_a = false, found_zircon_b = false, found_zircon_r = false;
   bool found_fvm = false, found_syscfg = false;

   for (uint32_t i = 0; i < gpt::kPartitionCount; i++) {
     gpt_partition_t* part = gpt->GetPartition(i);
     if (part == NULL) {
       continue;
     }
     if (!memcmp(part->type, kFvmGuid, GPT_GUID_LEN)) {
       if (!part_size_gte(part, kMinFvmSize, blk_info->block_size)) {
         continue;
       }
       found_fvm = true;
       continue;
     }
     if (!memcmp(part->type, kKernGuid, GPT_GUID_LEN)) {
       if (!part_size_gte(part, sz_kern, blk_info->block_size)) {
         continue;
       }
       if (part_name_eql(part, "ZIRCON-A")) {
         found_zircon_a = true;
       }
       if (part_name_eql(part, "ZIRCON-B")) {
         found_zircon_b = true;
       }
       if (part_name_eql(part, "ZIRCON-R")) {
         found_zircon_r = true;
       }
     }
     if (!memcmp(part->type, kSysCfgGuid, GPT_GUID_LEN)) {
       if (!part_size_gte(part, kSysCfgSize, blk_info->block_size)) {
         continue;
       }
       found_syscfg = true;
     }
   }
   if (!found_syscfg) {
     printf("cros-disk-setup: missing syscfg (or insufficient size)\n");
   }
   if (!found_fvm) {
     printf("cros-disk-setup: missing FVM (or insufficient size)\n");
   }
   if (!found_zircon_a || !found_zircon_b || !found_zircon_r) {
     printf("cros-disk-setup: missing one or more kernel partitions\n");
   }

   return found_zircon_a && found_zircon_b && found_zircon_r && found_fvm && found_syscfg;
 }

 zx_status_t config_cros_for_fuchsia(GptDevice* gpt,
                                     const fuchsia_hardware_block_BlockInfo* blk_info,
                                     const uint64_t sz_kern) {
   // TODO(raggi): this ends up getting called twice, as the canonical user,
   // the paver, calls is_ready_to_pave itself in order to determine first
   // whether it will need to sync the gpt.
   if (is_ready_to_pave(gpt, blk_info, sz_kern)) {
     return ZX_OK;
   }

   // TODO(ZX-1396): The gpt_device_t may not be valid for modification if it
   // is a newly initialized GPT which has never had gpt_device_finalize or
   // gpt_device_sync called.
   if (gpt->Finalize() != ZX_OK) {
     return ZX_ERR_INTERNAL;
   }

   // Remove the pre-existing Fuchsia partitions as when we were not already
   // pave-able and we're paving, assume that we want to tend toward a golden
   // layout. This also avoids any additional complexity that could arise from
   // intermediate gaps between these partitions.

   gpt_partition_t* p;
   if ((p = find_by_type_and_name(gpt, kKernGuid, "ZIRCON-A")) != NULL) {
     ZX_ASSERT(gpt->RemovePartition(p->guid) == ZX_OK);
   }
   if ((p = find_by_type_and_name(gpt, kKernGuid, "ZIRCON-B")) != NULL) {
     ZX_ASSERT(gpt->RemovePartition(p->guid) == ZX_OK);
   }
   if ((p = find_by_type_and_name(gpt, kKernGuid, "ZIRCON-R")) != NULL) {
     ZX_ASSERT(gpt->RemovePartition(p->guid) == ZX_OK);
   }
   if ((p = find_by_type(gpt, kFvmGuid)) != NULL) {
     ZX_ASSERT(gpt->RemovePartition(p->guid) == ZX_OK);
   }
   if ((p = find_by_type_and_name(gpt, kSysCfgGuid, "SYSCFG")) != NULL) {
     ZX_ASSERT(gpt->RemovePartition(p->guid) == ZX_OK);
   }

   // Space is required for 3 kernel partitions and one FVM partition that is
   // at least 8 kernels in size.
   uint64_t needed_space = sz_kern * 3 + kMinFvmSize + kSysCfgSize;

   // see if a contiguous block of space is available for space needed
   uint64_t blocks_needed = howmany(needed_space, blk_info->block_size);

   uint64_t hole_start, hole_end;
   bool found_hole = find_space(gpt, blocks_needed, &hole_start, &hole_end);

   // TODO(raggi): find a good heuristic to detect "old-paver" behavior, and if
   // we can detect that, remove the -C's, otherwise leave them alone.

   // First try removing the kernc and rootc partitions, as they're often a good fit for us:
   if (!found_hole) {
     // Some partitions were not large enough. If we found a KERN-C or a ROOT-C, delete them:
     if ((p = find_by_type_and_name(gpt, kKernGuid, "KERN-C")) != NULL) {
       ZX_ASSERT(gpt->RemovePartition(p->guid) == ZX_OK);
     }
     if ((p = find_by_type_and_name(gpt, kRootGuid, "ROOT-C")) != NULL) {
       ZX_ASSERT(gpt->RemovePartition(p->guid) == ZX_OK);
     }

     found_hole = find_space(gpt, blocks_needed, &hole_start, &hole_end);
   }

   // Still not enough contiguous space is available on disk, try shrinking STATE
   if (!found_hole && (p = find_by_type_and_name(gpt, kStateGuid, "STATE")) != NULL) {
     uint64_t min_state_sz_blks = howmany(MIN_SZ_STATE, blk_info->block_size);

     // TODO (TO-607) consider if there is free space on either side of STATE

     // The STATE partition is expected to be at the end of the GPT in cros,
     // and can be shrunk in order to make space for use cases such as this.
     // Here we first try to make the partition half of it's current size
     // (pinned to a minimum of min_sz_blks). This gives us a roughly equal
     // share of the free space on the disk.

     uint64_t state_part_blks = (p->last - p->first) + 1;
     uint64_t new_state_part_blks = state_part_blks / 2;
     if (new_state_part_blks < min_state_sz_blks) {
       new_state_part_blks = min_state_sz_blks;
     }
     uint64_t new_free_blks = state_part_blks - new_state_part_blks;

     if (new_free_blks >= blocks_needed) {
       p->first = p->first + new_free_blks;

       // find_space is re-run here as there is often a chunk of free space
       // left before the STATE partition that is not big enough for us to
       // fit, but is sensible to use which would not be used simply by
       // using the state->first offset.
       found_hole = find_space(gpt, blocks_needed, &hole_start, &hole_end);
     }
   }

   if (!found_hole) {
     return ZX_ERR_NO_SPACE;
   }

   printf("cros-disk-setup: Creating SYSCFG\n");
   zx_status_t status;
   uint64_t sz_syscfg_blks = howmany(kSysCfgSize, blk_info->block_size);
   if ((status = create_gpt_entry(gpt, hole_start, sz_syscfg_blks, kSysCfgGuid, "SYSCFG")) !=
       ZX_OK) {
     printf("cros-disk-setup: Error creating SYSCFG: %d\n", status);
     return ZX_ERR_INTERNAL;
   }
   hole_start += sz_syscfg_blks;

   uint64_t sz_kern_blks = howmany(sz_kern, blk_info->block_size);

   // Create GPT entries for ZIRCON-A, ZIRCON-B, ZIRCON-R and FVM if needed.
   const char* kernel_names[3] = {"ZIRCON-A", "ZIRCON-B", "ZIRCON-R"};
   for (size_t i = 0; i < 3; ++i) {
     printf("cros-disk-setup: Creating %s\n", kernel_names[i]);
     if ((status = create_gpt_entry(gpt, hole_start, sz_kern_blks, kKernGuid, kernel_names[i])) !=
         ZX_OK) {
       printf("cros-disk-setup: Error creating %s: %d\n", kernel_names[i], status);
       return ZX_ERR_INTERNAL;
     }
     hole_start += sz_kern_blks;
   }

   printf("cros-disk-setup: Creating FVM\n");

   // TODO(raggi): add this after the test setup supports it.
   // // clear the FVM superblock to ensure that a new FVM will be created there.
   // if (gpt_partition_clear(gpt, hole_start, 1) != 0) {
   //     printf("Error clearing FVM superblock.\n");
   //     return ZX_ERR_INTERNAL;
   // }

   // The created FVM partition will fill the available free space.
   if ((status = create_gpt_entry(gpt, hole_start, (hole_end - hole_start), kFvmGuid, "fvm")) !=
       ZX_OK) {
     printf("cros-disk-setup: Error creating FVM\n");
     return status;
   }

   // TODO(raggi): add this once the test setup supports it.
   // if (!gpt_device_finalize(gpt)) {
   //     printf("Error finalizing GPT\n");
   //     return ZX_ERR_INTERNAL;
   // }
   return ZX_OK;
 }

 __END_CDECLS

 }  // namespace chromeos_disk_setup
	// Copyright 2017 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 <stdbool.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/param.h>
	#include <zircon/assert.h>
	#include <zircon/device/block.h>
	#include <zircon/errors.h>
	#include <zircon/syscalls.h>
	#include <zircon/types.h>

	#include <chromeos-disk-setup/chromeos-disk-setup.h>
	#include <gpt/cros.h>
	#include <gpt/gpt.h>

	namespace chromeos_disk_setup {
	using gpt::GptDevice;
	namespace {

	constexpr uint8_t kFvmGuid[GPT_GUID_LEN] = GUID_FVM_VALUE;
	constexpr uint8_t kKernGuid[GPT_GUID_LEN] = GUID_CROS_KERNEL_VALUE;
	constexpr uint8_t kRootGuid[GPT_GUID_LEN] = GUID_CROS_ROOT_VALUE;
	constexpr uint8_t kStateGuid[GPT_GUID_LEN] = GUID_CROS_STATE_VALUE;
	constexpr uint8_t kSysCfgGuid[GPT_GUID_LEN] = GUID_SYS_CONFIG_VALUE;

	// this value is shared with device-partitioner.cpp
	constexpr uint64_t kMinFvmSize = 8LU * (1 << 30);

	constexpr uint64_t kSysCfgSize = 1 << 20;

	// part_name_eql compares the name field in the given partition to the cstring
	// name, returning true if the partition name is equal to name and zero-padded.
	bool part_name_eql(const gpt_partition_t* part, const char* name) {
	if (part == NULL) {
	return false;
	}
	char buf[GPT_NAME_LEN] = {0};
	utf16_to_cstring(&buf[0], (const uint16_t*)part->name, GPT_NAME_LEN / 2);
	return !strncmp(buf, name, GPT_NAME_LEN);
	}

	// part_name_guid_eql returns true if the given partition has the given name and
	// the given type GUID, false otherwise.
	bool part_name_guid_eql(const gpt_partition_t* part, const char* name,
	const uint8_t guid[GPT_GUID_LEN]) {
	if (part == NULL) {
	return false;
	}
	if (!memcmp(part->type, &guid[0], GPT_GUID_LEN) && part_name_eql(part, name)) {
	return true;
	}
	return false;
	}

	// part_size_gte returns true if the partition size is greater than or equal to
	// the size given, false otherwise.
	bool part_size_gte(gpt_partition_t* part, uint64_t size, uint64_t block_size) {
	if (part == NULL) {
	return false;
	}
	uint64_t size_in_blocks = part->last - part->first + 1;
	return size_in_blocks * block_size >= size;
	}

	// find_by_type finds the first partition matching the given type guid.
	gpt_partition_t* find_by_type(const GptDevice* gpt, const uint8_t type_guid[GPT_GUID_LEN]) {
	for (uint32_t i = 0; i < gpt::kPartitionCount; ++i) {
	gpt_partition_t* p = gpt->GetPartition(i);
	if (p == NULL) {
	continue;
	}
	if (!memcmp(p->type, &type_guid[0], GPT_GUID_LEN)) {
	return p;
	}
	}
	return NULL;
	}

	// find_by_type_and_name finds the first partition matching the given type guid and name.
	gpt_partition_t* find_by_type_and_name(const GptDevice* gpt, const uint8_t type_guid[GPT_GUID_LEN],
	const char* name) {
	for (uint32_t i = 0; i < gpt::kPartitionCount; ++i) {
	gpt_partition_t* p = gpt->GetPartition(i);
	if (p == NULL) {
	continue;
	}
	if (part_name_guid_eql(p, name, type_guid)) {
	return p;
	}
	}
	return NULL;
	}

	// Find a contiguous run of free space on the disk at least blocks_req in length.
	// If space is found, true is returned and out_hole_start and out_hole_end
	// contain the first free and last free blocks in a contiguous run.
	bool find_space(GptDevice* gpt, const uint64_t blocks_req, uint64_t* out_hole_start,
	uint64_t* out_hole_end) {
	gpt_partition_t* parts[gpt::kPartitionCount] = {0};
	for (uint32_t i = 0; i < gpt::kPartitionCount; i++) {
	parts[i] = gpt->GetPartition(i);
	}

	// XXX(raggi): once the lib supports more and less than gpt::kPartitionCount,
	// this will need to be fixed (as will many loops).
	gpt_sort_partitions(parts, gpt::kPartitionCount);

	uint64_t first_usable, last_usable;
	ZX_ASSERT(gpt->Range(&first_usable, &last_usable) == ZX_OK);

	uint64_t prev_end = first_usable - 1;
	for (uint32_t i = 0; i < gpt::kPartitionCount; i++) {
	if (parts[i] == NULL) {
	continue;
	}

	// TODO(raggi): find out how the tests end up making this state
	if (parts[i]->first >= last_usable \|\| parts[i]->last >= last_usable) {
	break;
	}

	uint64_t gap = parts[i]->first - (prev_end + 1);
	if (gap >= blocks_req) {
	*out_hole_start = prev_end + 1;
	*out_hole_end = parts[i]->first - 1;

	return true;
	}
	prev_end = parts[i]->last;
	}

	if (prev_end < last_usable && last_usable - (prev_end + 1) >= blocks_req) {
	*out_hole_start = prev_end + 1;
	*out_hole_end = last_usable;

	return true;
	}

	return false;
	}

	// create a GPT entry with the supplied attributes and assign it a random
	// GUID. May return an error if the GUID can not be generated for the partition
	// or operations on the gpt_device_t fail.
	zx_status_t create_gpt_entry(GptDevice* gpt, const uint64_t first, const uint64_t blks,
	const uint8_t type[GPT_GUID_LEN], const char* name) {
	uint8_t guid[GPT_GUID_LEN];
	zx_cprng_draw(guid, GPT_GUID_LEN);

	uint8_t tguid[GPT_GUID_LEN];
	memcpy(&tguid, type, GPT_GUID_LEN);
	if (gpt->AddPartition(name, tguid, guid, first, blks, 0) != ZX_OK) {
	return ZX_ERR_INTERNAL;
	}

	return ZX_OK;
	}

	} // namespace

	__BEGIN_CDECLS

	bool is_cros(const GptDevice* gpt) {
	uint8_t roots = 0;
	uint8_t kerns = 0;
	bool state = false;

	for (uint32_t i = 0; i < gpt::kPartitionCount; ++i) {
	gpt_partition_t* p = gpt->GetPartition(i);
	if (p == NULL) {
	continue;
	}

	if (!memcmp(p->type, kRootGuid, GPT_GUID_LEN) &&
	(part_name_eql(p, "ROOT-A") \|\| part_name_eql(p, "ROOT-B"))) {
	roots++;
	} else if (!memcmp(p->type, kKernGuid, GPT_GUID_LEN) &&
	(part_name_eql(p, "KERN-A") \|\| part_name_eql(p, "KERN-B"))) {
	kerns++;
	} else if (!memcmp(p->type, kStateGuid, GPT_GUID_LEN) && part_name_eql(p, "STATE")) {
	state = true;
	}
	}

	return state && roots >= 2 && kerns >= 2;
	}

	// is_ready_to_pave returns true if there exist partitions for:
	// * ZIRCON-A is a GUID_CROS_KERNEL_VALUE at least sz_kern in size.
	// * ZIRCON-B is a GUID_CROS_KERNEL_VALUE at least sz_kern in size.
	// * ZIRCON-R is a GUID_CROS_KERNEL_VALUE at least sz_kern in size.
	// * FVM is a GUID_FVM_VALUE at least sz_kern * 8 in size
	bool is_ready_to_pave(const GptDevice* gpt, const fuchsia_hardware_block_BlockInfo* blk_info,
	const uint64_t sz_kern) {
	bool found_zircon_a = false, found_zircon_b = false, found_zircon_r = false;
	bool found_fvm = false, found_syscfg = false;

	for (uint32_t i = 0; i < gpt::kPartitionCount; i++) {
	gpt_partition_t* part = gpt->GetPartition(i);
	if (part == NULL) {
	continue;
	}
	if (!memcmp(part->type, kFvmGuid, GPT_GUID_LEN)) {
	if (!part_size_gte(part, kMinFvmSize, blk_info->block_size)) {
	continue;
	}
	found_fvm = true;
	continue;
	}
	if (!memcmp(part->type, kKernGuid, GPT_GUID_LEN)) {
	if (!part_size_gte(part, sz_kern, blk_info->block_size)) {
	continue;
	}
	if (part_name_eql(part, "ZIRCON-A")) {
	found_zircon_a = true;
	}
	if (part_name_eql(part, "ZIRCON-B")) {
	found_zircon_b = true;
	}
	if (part_name_eql(part, "ZIRCON-R")) {
	found_zircon_r = true;
	}
	}
	if (!memcmp(part->type, kSysCfgGuid, GPT_GUID_LEN)) {
	if (!part_size_gte(part, kSysCfgSize, blk_info->block_size)) {
	continue;
	}
	found_syscfg = true;
	}
	}
	if (!found_syscfg) {
	printf("cros-disk-setup: missing syscfg (or insufficient size)\n");
	}
	if (!found_fvm) {
	printf("cros-disk-setup: missing FVM (or insufficient size)\n");
	}
	if (!found_zircon_a \|\| !found_zircon_b \|\| !found_zircon_r) {
	printf("cros-disk-setup: missing one or more kernel partitions\n");
	}

	return found_zircon_a && found_zircon_b && found_zircon_r && found_fvm && found_syscfg;
	}

	zx_status_t config_cros_for_fuchsia(GptDevice* gpt,
	const fuchsia_hardware_block_BlockInfo* blk_info,
	const uint64_t sz_kern) {
	// TODO(raggi): this ends up getting called twice, as the canonical user,
	// the paver, calls is_ready_to_pave itself in order to determine first
	// whether it will need to sync the gpt.
	if (is_ready_to_pave(gpt, blk_info, sz_kern)) {
	return ZX_OK;
	}

	// TODO(ZX-1396): The gpt_device_t may not be valid for modification if it
	// is a newly initialized GPT which has never had gpt_device_finalize or
	// gpt_device_sync called.
	if (gpt->Finalize() != ZX_OK) {
	return ZX_ERR_INTERNAL;
	}

	// Remove the pre-existing Fuchsia partitions as when we were not already
	// pave-able and we're paving, assume that we want to tend toward a golden
	// layout. This also avoids any additional complexity that could arise from
	// intermediate gaps between these partitions.

	gpt_partition_t* p;
	if ((p = find_by_type_and_name(gpt, kKernGuid, "ZIRCON-A")) != NULL) {
	ZX_ASSERT(gpt->RemovePartition(p->guid) == ZX_OK);
	}
	if ((p = find_by_type_and_name(gpt, kKernGuid, "ZIRCON-B")) != NULL) {
	ZX_ASSERT(gpt->RemovePartition(p->guid) == ZX_OK);
	}
	if ((p = find_by_type_and_name(gpt, kKernGuid, "ZIRCON-R")) != NULL) {
	ZX_ASSERT(gpt->RemovePartition(p->guid) == ZX_OK);
	}
	if ((p = find_by_type(gpt, kFvmGuid)) != NULL) {
	ZX_ASSERT(gpt->RemovePartition(p->guid) == ZX_OK);
	}
	if ((p = find_by_type_and_name(gpt, kSysCfgGuid, "SYSCFG")) != NULL) {
	ZX_ASSERT(gpt->RemovePartition(p->guid) == ZX_OK);
	}

	// Space is required for 3 kernel partitions and one FVM partition that is
	// at least 8 kernels in size.
	uint64_t needed_space = sz_kern * 3 + kMinFvmSize + kSysCfgSize;

	// see if a contiguous block of space is available for space needed
	uint64_t blocks_needed = howmany(needed_space, blk_info->block_size);

	uint64_t hole_start, hole_end;
	bool found_hole = find_space(gpt, blocks_needed, &hole_start, &hole_end);

	// TODO(raggi): find a good heuristic to detect "old-paver" behavior, and if
	// we can detect that, remove the -C's, otherwise leave them alone.

	// First try removing the kernc and rootc partitions, as they're often a good fit for us:
	if (!found_hole) {
	// Some partitions were not large enough. If we found a KERN-C or a ROOT-C, delete them:
	if ((p = find_by_type_and_name(gpt, kKernGuid, "KERN-C")) != NULL) {
	ZX_ASSERT(gpt->RemovePartition(p->guid) == ZX_OK);
	}
	if ((p = find_by_type_and_name(gpt, kRootGuid, "ROOT-C")) != NULL) {
	ZX_ASSERT(gpt->RemovePartition(p->guid) == ZX_OK);
	}

	found_hole = find_space(gpt, blocks_needed, &hole_start, &hole_end);
	}

	// Still not enough contiguous space is available on disk, try shrinking STATE
	if (!found_hole && (p = find_by_type_and_name(gpt, kStateGuid, "STATE")) != NULL) {
	uint64_t min_state_sz_blks = howmany(MIN_SZ_STATE, blk_info->block_size);

	// TODO (TO-607) consider if there is free space on either side of STATE

	// The STATE partition is expected to be at the end of the GPT in cros,
	// and can be shrunk in order to make space for use cases such as this.
	// Here we first try to make the partition half of it's current size
	// (pinned to a minimum of min_sz_blks). This gives us a roughly equal
	// share of the free space on the disk.

	uint64_t state_part_blks = (p->last - p->first) + 1;
	uint64_t new_state_part_blks = state_part_blks / 2;
	if (new_state_part_blks < min_state_sz_blks) {
	new_state_part_blks = min_state_sz_blks;
	}
	uint64_t new_free_blks = state_part_blks - new_state_part_blks;

	if (new_free_blks >= blocks_needed) {
	p->first = p->first + new_free_blks;

	// find_space is re-run here as there is often a chunk of free space
	// left before the STATE partition that is not big enough for us to
	// fit, but is sensible to use which would not be used simply by
	// using the state->first offset.
	found_hole = find_space(gpt, blocks_needed, &hole_start, &hole_end);
	}
	}

	if (!found_hole) {
	return ZX_ERR_NO_SPACE;
	}

	printf("cros-disk-setup: Creating SYSCFG\n");
	zx_status_t status;
	uint64_t sz_syscfg_blks = howmany(kSysCfgSize, blk_info->block_size);
	if ((status = create_gpt_entry(gpt, hole_start, sz_syscfg_blks, kSysCfgGuid, "SYSCFG")) !=
	ZX_OK) {
	printf("cros-disk-setup: Error creating SYSCFG: %d\n", status);
	return ZX_ERR_INTERNAL;
	}
	hole_start += sz_syscfg_blks;

	uint64_t sz_kern_blks = howmany(sz_kern, blk_info->block_size);

	// Create GPT entries for ZIRCON-A, ZIRCON-B, ZIRCON-R and FVM if needed.
	const char* kernel_names[3] = {"ZIRCON-A", "ZIRCON-B", "ZIRCON-R"};
	for (size_t i = 0; i < 3; ++i) {
	printf("cros-disk-setup: Creating %s\n", kernel_names[i]);
	if ((status = create_gpt_entry(gpt, hole_start, sz_kern_blks, kKernGuid, kernel_names[i])) !=
	ZX_OK) {
	printf("cros-disk-setup: Error creating %s: %d\n", kernel_names[i], status);
	return ZX_ERR_INTERNAL;
	}
	hole_start += sz_kern_blks;
	}

	printf("cros-disk-setup: Creating FVM\n");

	// TODO(raggi): add this after the test setup supports it.
	// // clear the FVM superblock to ensure that a new FVM will be created there.
	// if (gpt_partition_clear(gpt, hole_start, 1) != 0) {
	// printf("Error clearing FVM superblock.\n");
	// return ZX_ERR_INTERNAL;
	// }

	// The created FVM partition will fill the available free space.
	if ((status = create_gpt_entry(gpt, hole_start, (hole_end - hole_start), kFvmGuid, "fvm")) !=
	ZX_OK) {
	printf("cros-disk-setup: Error creating FVM\n");
	return status;
	}

	// TODO(raggi): add this once the test setup supports it.
	// if (!gpt_device_finalize(gpt)) {
	// printf("Error finalizing GPT\n");
	// return ZX_ERR_INTERNAL;
	// }
	return ZX_OK;
	}

	__END_CDECLS

	} // namespace chromeos_disk_setup