| /* |
| * Copyright (C) 2019 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 "host/commands/assemble_cvd/disk_flags.h" |
| |
| #include <android-base/logging.h> |
| #include <android-base/strings.h> |
| #include <fruit/fruit.h> |
| #include <gflags/gflags.h> |
| #include <sys/statvfs.h> |
| |
| #include <fstream> |
| |
| #include "common/libs/fs/shared_buf.h" |
| #include "common/libs/utils/environment.h" |
| #include "common/libs/utils/files.h" |
| #include "common/libs/utils/size_utils.h" |
| #include "common/libs/utils/subprocess.h" |
| #include "host/commands/assemble_cvd/boot_config.h" |
| #include "host/commands/assemble_cvd/boot_image_utils.h" |
| #include "host/commands/assemble_cvd/disk_builder.h" |
| #include "host/commands/assemble_cvd/super_image_mixer.h" |
| #include "host/libs/config/bootconfig_args.h" |
| #include "host/libs/config/cuttlefish_config.h" |
| #include "host/libs/config/data_image.h" |
| #include "host/libs/vm_manager/crosvm_manager.h" |
| #include "host/libs/vm_manager/gem5_manager.h" |
| |
| // Taken from external/avb/libavb/avb_slot_verify.c; this define is not in the headers |
| #define VBMETA_MAX_SIZE 65536ul |
| // Taken from external/avb/avbtool.py; this define is not in the headers |
| #define MAX_AVB_METADATA_SIZE 69632ul |
| |
| DECLARE_string(system_image_dir); |
| |
| DEFINE_string(boot_image, "", |
| "Location of cuttlefish boot image. If empty it is assumed to be " |
| "boot.img in the directory specified by -system_image_dir."); |
| DEFINE_string( |
| init_boot_image, "", |
| "Location of cuttlefish init boot image. If empty it is assumed to " |
| "be init_boot.img in the directory specified by -system_image_dir."); |
| DEFINE_string(data_image, "", "Location of the data partition image."); |
| DEFINE_string(super_image, "", "Location of the super partition image."); |
| DEFINE_string(misc_image, "", |
| "Location of the misc partition image. If the image does not " |
| "exist, a blank new misc partition image is created."); |
| DEFINE_string(metadata_image, "", "Location of the metadata partition image " |
| "to be generated."); |
| DEFINE_string(vendor_boot_image, "", |
| "Location of cuttlefish vendor boot image. If empty it is assumed to " |
| "be vendor_boot.img in the directory specified by -system_image_dir."); |
| DEFINE_string(vbmeta_image, "", |
| "Location of cuttlefish vbmeta image. If empty it is assumed to " |
| "be vbmeta.img in the directory specified by -system_image_dir."); |
| DEFINE_string(vbmeta_system_image, "", |
| "Location of cuttlefish vbmeta_system image. If empty it is assumed to " |
| "be vbmeta_system.img in the directory specified by -system_image_dir."); |
| DEFINE_string(otheros_esp_image, "", |
| "Location of cuttlefish esp image. If the image does not exist, " |
| "and --otheros_root_image is specified, an esp partition image " |
| "is created with default bootloaders."); |
| DEFINE_string(otheros_kernel_path, "", |
| "Location of cuttlefish otheros kernel."); |
| DEFINE_string(otheros_initramfs_path, "", |
| "Location of cuttlefish otheros initramfs.img."); |
| DEFINE_string(otheros_root_image, "", |
| "Location of cuttlefish otheros root filesystem image."); |
| |
| DEFINE_int32(blank_metadata_image_mb, 16, |
| "The size of the blank metadata image to generate, MB."); |
| DEFINE_int32(blank_sdcard_image_mb, 2048, |
| "If enabled, the size of the blank sdcard image to generate, MB."); |
| |
| DECLARE_string(ap_rootfs_image); |
| DECLARE_string(bootloader); |
| DECLARE_bool(use_sdcard); |
| DECLARE_string(initramfs_path); |
| DECLARE_string(kernel_path); |
| DECLARE_bool(resume); |
| DECLARE_bool(protected_vm); |
| |
| namespace cuttlefish { |
| |
| using vm_manager::Gem5Manager; |
| |
| Result<void> ResolveInstanceFiles() { |
| CF_EXPECT(!FLAGS_system_image_dir.empty(), |
| "--system_image_dir must be specified."); |
| |
| // If user did not specify location of either of these files, expect them to |
| // be placed in --system_image_dir location. |
| std::string default_boot_image = FLAGS_system_image_dir + "/boot.img"; |
| SetCommandLineOptionWithMode("boot_image", default_boot_image.c_str(), |
| google::FlagSettingMode::SET_FLAGS_DEFAULT); |
| std::string default_init_boot_image = |
| FLAGS_system_image_dir + "/init_boot.img"; |
| SetCommandLineOptionWithMode("init_boot_image", |
| default_init_boot_image.c_str(), |
| google::FlagSettingMode::SET_FLAGS_DEFAULT); |
| std::string default_data_image = FLAGS_system_image_dir + "/userdata.img"; |
| SetCommandLineOptionWithMode("data_image", default_data_image.c_str(), |
| google::FlagSettingMode::SET_FLAGS_DEFAULT); |
| std::string default_metadata_image = FLAGS_system_image_dir + "/metadata.img"; |
| SetCommandLineOptionWithMode("metadata_image", default_metadata_image.c_str(), |
| google::FlagSettingMode::SET_FLAGS_DEFAULT); |
| std::string default_super_image = FLAGS_system_image_dir + "/super.img"; |
| SetCommandLineOptionWithMode("super_image", default_super_image.c_str(), |
| google::FlagSettingMode::SET_FLAGS_DEFAULT); |
| std::string default_misc_image = FLAGS_system_image_dir + "/misc.img"; |
| SetCommandLineOptionWithMode("misc_image", default_misc_image.c_str(), |
| google::FlagSettingMode::SET_FLAGS_DEFAULT); |
| std::string default_esp_image = FLAGS_system_image_dir + "/esp.img"; |
| SetCommandLineOptionWithMode("otheros_esp_image", default_esp_image.c_str(), |
| google::FlagSettingMode::SET_FLAGS_DEFAULT); |
| std::string default_vendor_boot_image = FLAGS_system_image_dir |
| + "/vendor_boot.img"; |
| SetCommandLineOptionWithMode("vendor_boot_image", |
| default_vendor_boot_image.c_str(), |
| google::FlagSettingMode::SET_FLAGS_DEFAULT); |
| std::string default_vbmeta_image = FLAGS_system_image_dir + "/vbmeta.img"; |
| SetCommandLineOptionWithMode("vbmeta_image", default_vbmeta_image.c_str(), |
| google::FlagSettingMode::SET_FLAGS_DEFAULT); |
| std::string default_vbmeta_system_image = FLAGS_system_image_dir |
| + "/vbmeta_system.img"; |
| SetCommandLineOptionWithMode("vbmeta_system_image", |
| default_vbmeta_system_image.c_str(), |
| google::FlagSettingMode::SET_FLAGS_DEFAULT); |
| |
| return {}; |
| } |
| |
| std::vector<ImagePartition> GetOsCompositeDiskConfig() { |
| std::vector<ImagePartition> partitions; |
| partitions.push_back(ImagePartition{ |
| .label = "misc", |
| .image_file_path = AbsolutePath(FLAGS_misc_image), |
| .read_only = true, |
| }); |
| partitions.push_back(ImagePartition{ |
| .label = "boot_a", |
| .image_file_path = AbsolutePath(FLAGS_boot_image), |
| .read_only = true, |
| }); |
| partitions.push_back(ImagePartition{ |
| .label = "boot_b", |
| .image_file_path = AbsolutePath(FLAGS_boot_image), |
| .read_only = true, |
| }); |
| partitions.push_back(ImagePartition{ |
| .label = "init_boot_a", |
| .image_file_path = AbsolutePath(FLAGS_init_boot_image), |
| .read_only = true, |
| }); |
| partitions.push_back(ImagePartition{ |
| .label = "init_boot_b", |
| .image_file_path = AbsolutePath(FLAGS_init_boot_image), |
| .read_only = true, |
| }); |
| partitions.push_back(ImagePartition{ |
| .label = "vendor_boot_a", |
| .image_file_path = AbsolutePath(FLAGS_vendor_boot_image), |
| .read_only = true, |
| }); |
| partitions.push_back(ImagePartition{ |
| .label = "vendor_boot_b", |
| .image_file_path = AbsolutePath(FLAGS_vendor_boot_image), |
| .read_only = true, |
| }); |
| partitions.push_back(ImagePartition{ |
| .label = "vbmeta_a", |
| .image_file_path = AbsolutePath(FLAGS_vbmeta_image), |
| .read_only = true, |
| }); |
| partitions.push_back(ImagePartition{ |
| .label = "vbmeta_b", |
| .image_file_path = AbsolutePath(FLAGS_vbmeta_image), |
| .read_only = true, |
| }); |
| partitions.push_back(ImagePartition{ |
| .label = "vbmeta_system_a", |
| .image_file_path = AbsolutePath(FLAGS_vbmeta_system_image), |
| .read_only = true, |
| }); |
| partitions.push_back(ImagePartition{ |
| .label = "vbmeta_system_b", |
| .image_file_path = AbsolutePath(FLAGS_vbmeta_system_image), |
| .read_only = true, |
| }); |
| partitions.push_back(ImagePartition{ |
| .label = "super", |
| .image_file_path = AbsolutePath(FLAGS_super_image), |
| .read_only = true, |
| }); |
| partitions.push_back(ImagePartition{ |
| .label = "userdata", |
| .image_file_path = AbsolutePath(FLAGS_data_image), |
| .read_only = true, |
| }); |
| partitions.push_back(ImagePartition{ |
| .label = "metadata", |
| .image_file_path = AbsolutePath(FLAGS_metadata_image), |
| .read_only = true, |
| }); |
| if (!FLAGS_otheros_root_image.empty()) { |
| partitions.push_back(ImagePartition{ |
| .label = "otheros_esp", |
| .image_file_path = AbsolutePath(FLAGS_otheros_esp_image), |
| .type = kEfiSystemPartition, |
| .read_only = true, |
| }); |
| partitions.push_back(ImagePartition{ |
| .label = "otheros_root", |
| .image_file_path = AbsolutePath(FLAGS_otheros_root_image), |
| .read_only = true, |
| }); |
| } |
| if (!FLAGS_ap_rootfs_image.empty()) { |
| partitions.push_back(ImagePartition{ |
| .label = "ap_rootfs", |
| .image_file_path = AbsolutePath(FLAGS_ap_rootfs_image), |
| .read_only = true, |
| }); |
| } |
| return partitions; |
| } |
| |
| DiskBuilder OsCompositeDiskBuilder(const CuttlefishConfig& config) { |
| return DiskBuilder() |
| .Partitions(GetOsCompositeDiskConfig()) |
| .VmManager(config.vm_manager()) |
| .CrosvmPath(config.crosvm_binary()) |
| .ConfigPath(config.AssemblyPath("os_composite_disk_config.txt")) |
| .HeaderPath(config.AssemblyPath("os_composite_gpt_header.img")) |
| .FooterPath(config.AssemblyPath("os_composite_gpt_footer.img")) |
| .CompositeDiskPath(config.os_composite_disk_path()) |
| .ResumeIfPossible(FLAGS_resume); |
| } |
| |
| std::vector<ImagePartition> persistent_composite_disk_config( |
| const CuttlefishConfig& config, |
| const CuttlefishConfig::InstanceSpecific& instance) { |
| std::vector<ImagePartition> partitions; |
| |
| // Note that if the position of uboot_env changes, the environment for |
| // u-boot must be updated as well (see boot_config.cc and |
| // cuttlefish.fragment in external/u-boot). |
| partitions.push_back(ImagePartition{ |
| .label = "uboot_env", |
| .image_file_path = AbsolutePath(instance.uboot_env_image_path()), |
| }); |
| partitions.push_back(ImagePartition{ |
| .label = "vbmeta", |
| .image_file_path = AbsolutePath(instance.vbmeta_path()), |
| }); |
| if (!FLAGS_protected_vm) { |
| partitions.push_back(ImagePartition{ |
| .label = "frp", |
| .image_file_path = |
| AbsolutePath(instance.factory_reset_protected_path()), |
| }); |
| } |
| if (config.bootconfig_supported()) { |
| partitions.push_back(ImagePartition{ |
| .label = "bootconfig", |
| .image_file_path = AbsolutePath(instance.persistent_bootconfig_path()), |
| }); |
| } |
| return partitions; |
| } |
| |
| static uint64_t AvailableSpaceAtPath(const std::string& path) { |
| struct statvfs vfs; |
| if (statvfs(path.c_str(), &vfs) != 0) { |
| int error_num = errno; |
| LOG(ERROR) << "Could not find space available at " << path << ", error was " |
| << strerror(error_num); |
| return 0; |
| } |
| // f_frsize (block size) * f_bavail (free blocks) for unprivileged users. |
| return static_cast<uint64_t>(vfs.f_frsize) * vfs.f_bavail; |
| } |
| |
| class BootImageRepacker : public SetupFeature { |
| public: |
| INJECT(BootImageRepacker(const CuttlefishConfig& config)) : config_(config) {} |
| |
| // SetupFeature |
| std::string Name() const override { return "BootImageRepacker"; } |
| std::unordered_set<SetupFeature*> Dependencies() const override { return {}; } |
| bool Enabled() const override { |
| // If we are booting a protected VM, for now, assume that image repacking |
| // isn't trusted. Repacking requires resigning the image and keys from an |
| // android host aren't trusted. |
| return !config_.protected_vm(); |
| } |
| |
| protected: |
| bool Setup() override { |
| if (!FileHasContent(FLAGS_boot_image)) { |
| LOG(ERROR) << "File not found: " << FLAGS_boot_image; |
| return false; |
| } |
| // The init_boot partition is be optional for testing boot.img |
| // with the ramdisk inside. |
| if (!FileHasContent(FLAGS_init_boot_image)) { |
| LOG(WARNING) << "File not found: " << FLAGS_init_boot_image; |
| } |
| |
| if (!FileHasContent(FLAGS_vendor_boot_image)) { |
| LOG(ERROR) << "File not found: " << FLAGS_vendor_boot_image; |
| return false; |
| } |
| |
| // Repacking a boot.img doesn't work with Gem5 because the user must always |
| // specify a vmlinux instead of an arm64 Image, and that file can be too |
| // large to be repacked. Skip repack of boot.img on Gem5, as we need to be |
| // able to extract the ramdisk.img in a later stage and so this step must |
| // not fail (..and the repacked kernel wouldn't be used anyway). |
| if (FLAGS_kernel_path.size() && |
| config_.vm_manager() != Gem5Manager::name()) { |
| const std::string new_boot_image_path = |
| config_.AssemblyPath("boot_repacked.img"); |
| bool success = |
| RepackBootImage(FLAGS_kernel_path, FLAGS_boot_image, |
| new_boot_image_path, config_.assembly_dir()); |
| if (!success) { |
| LOG(ERROR) << "Failed to regenerate the boot image with the new kernel"; |
| return false; |
| } |
| SetCommandLineOptionWithMode("boot_image", new_boot_image_path.c_str(), |
| google::FlagSettingMode::SET_FLAGS_DEFAULT); |
| } |
| |
| if (FLAGS_kernel_path.size() || FLAGS_initramfs_path.size()) { |
| const std::string new_vendor_boot_image_path = |
| config_.AssemblyPath("vendor_boot_repacked.img"); |
| // Repack the vendor boot images if kernels and/or ramdisks are passed in. |
| if (FLAGS_initramfs_path.size()) { |
| bool success = RepackVendorBootImage( |
| FLAGS_initramfs_path, FLAGS_vendor_boot_image, |
| new_vendor_boot_image_path, config_.assembly_dir(), |
| config_.bootconfig_supported()); |
| if (!success) { |
| LOG(ERROR) << "Failed to regenerate the vendor boot image with the " |
| "new ramdisk"; |
| } else { |
| // This control flow implies a kernel with all configs built in. |
| // If it's just the kernel, repack the vendor boot image without a |
| // ramdisk. |
| bool success = RepackVendorBootImageWithEmptyRamdisk( |
| FLAGS_vendor_boot_image, new_vendor_boot_image_path, |
| config_.assembly_dir(), config_.bootconfig_supported()); |
| if (!success) { |
| LOG(ERROR) << "Failed to regenerate the vendor boot image without " |
| "a ramdisk"; |
| return false; |
| } |
| } |
| SetCommandLineOptionWithMode( |
| "vendor_boot_image", new_vendor_boot_image_path.c_str(), |
| google::FlagSettingMode::SET_FLAGS_DEFAULT); |
| } |
| } |
| return true; |
| } |
| |
| private: |
| const CuttlefishConfig& config_; |
| }; |
| |
| class Gem5ImageUnpacker : public SetupFeature { |
| public: |
| INJECT(Gem5ImageUnpacker( |
| const CuttlefishConfig& config, |
| BootImageRepacker& bir)) |
| : config_(config), |
| bir_(bir) {} |
| |
| // SetupFeature |
| std::string Name() const override { return "Gem5ImageUnpacker"; } |
| |
| std::unordered_set<SetupFeature*> Dependencies() const override { |
| return { |
| static_cast<SetupFeature*>(&bir_), |
| }; |
| } |
| |
| bool Enabled() const override { |
| // Everything has a bootloader except gem5, so only run this for gem5 |
| return config_.vm_manager() == Gem5Manager::name(); |
| } |
| |
| protected: |
| bool Setup() override { |
| /* Unpack the original or repacked boot and vendor boot ramdisks, so that |
| * we have access to the baked bootconfig and raw compressed ramdisks. |
| * This allows us to emulate what a bootloader would normally do, which |
| * Gem5 can't support itself. This code also copies the kernel again |
| * (because Gem5 only supports raw vmlinux) and handles the bootloader |
| * binaries specially. This code is just part of the solution; it only |
| * does the parts which are instance agnostic. |
| */ |
| |
| if (!FileHasContent(FLAGS_boot_image)) { |
| LOG(ERROR) << "File not found: " << FLAGS_boot_image; |
| return false; |
| } |
| // The init_boot partition is be optional for testing boot.img |
| // with the ramdisk inside. |
| if (!FileHasContent(FLAGS_init_boot_image)) { |
| LOG(WARNING) << "File not found: " << FLAGS_init_boot_image; |
| } |
| |
| if (!FileHasContent(FLAGS_vendor_boot_image)) { |
| LOG(ERROR) << "File not found: " << FLAGS_vendor_boot_image; |
| return false; |
| } |
| |
| const std::string unpack_dir = config_.assembly_dir(); |
| |
| bool success = UnpackBootImage(FLAGS_init_boot_image, unpack_dir); |
| if (!success) { |
| LOG(ERROR) << "Failed to extract the init boot image"; |
| return false; |
| } |
| |
| success = UnpackVendorBootImageIfNotUnpacked(FLAGS_vendor_boot_image, |
| unpack_dir); |
| if (!success) { |
| LOG(ERROR) << "Failed to extract the vendor boot image"; |
| return false; |
| } |
| |
| // Assume the user specified a kernel manually which is a vmlinux |
| std::ofstream kernel(unpack_dir + "/kernel", std::ios_base::binary | |
| std::ios_base::trunc); |
| std::ifstream vmlinux(FLAGS_kernel_path, std::ios_base::binary); |
| kernel << vmlinux.rdbuf(); |
| kernel.close(); |
| |
| // Gem5 needs the bootloader binary to be a specific directory structure |
| // to find it. Create a 'binaries' directory and copy it into there |
| const std::string binaries_dir = unpack_dir + "/binaries"; |
| if (mkdir(binaries_dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) < 0 |
| && errno != EEXIST) { |
| PLOG(ERROR) << "Failed to create dir: \"" << binaries_dir << "\" "; |
| return false; |
| } |
| std::ofstream bootloader(binaries_dir + "/" + |
| cpp_basename(FLAGS_bootloader), |
| std::ios_base::binary | std::ios_base::trunc); |
| std::ifstream src_bootloader(FLAGS_bootloader, std::ios_base::binary); |
| bootloader << src_bootloader.rdbuf(); |
| bootloader.close(); |
| |
| // Gem5 also needs the ARM version of the bootloader, even though it |
| // doesn't use it. It'll even open it to check it's a valid ELF file. |
| // Work around this by copying such a named file from the same directory |
| std::ofstream boot_arm(binaries_dir + "/boot.arm", |
| std::ios_base::binary | std::ios_base::trunc); |
| std::ifstream src_boot_arm(cpp_dirname(FLAGS_bootloader) + "/boot.arm", |
| std::ios_base::binary); |
| boot_arm << src_boot_arm.rdbuf(); |
| boot_arm.close(); |
| |
| return true; |
| } |
| |
| private: |
| const CuttlefishConfig& config_; |
| BootImageRepacker& bir_; |
| }; |
| |
| class GeneratePersistentBootconfig : public SetupFeature { |
| public: |
| INJECT(GeneratePersistentBootconfig( |
| const CuttlefishConfig& config, |
| const CuttlefishConfig::InstanceSpecific& instance)) |
| : config_(config), instance_(instance) {} |
| |
| // SetupFeature |
| std::string Name() const override { |
| return "GeneratePersistentBootconfig"; |
| } |
| bool Enabled() const override { |
| return (!config_.protected_vm()); |
| } |
| |
| private: |
| std::unordered_set<SetupFeature*> Dependencies() const override { return {}; } |
| bool Setup() override { |
| // Cuttlefish for the time being won't be able to support OTA from a |
| // non-bootconfig kernel to a bootconfig-kernel (or vice versa) IF the |
| // device is stopped (via stop_cvd). This is rarely an issue since OTA |
| // testing run on cuttlefish is done within one launch cycle of the device. |
| // If this ever becomes an issue, this code will have to be rewritten. |
| if(!config_.bootconfig_supported()) { |
| return true; |
| } |
| |
| const auto bootconfig_path = instance_.persistent_bootconfig_path(); |
| if (!FileExists(bootconfig_path)) { |
| if (!CreateBlankImage(bootconfig_path, 1 /* mb */, "none")) { |
| LOG(ERROR) << "Failed to create image at " << bootconfig_path; |
| return false; |
| } |
| } |
| |
| auto bootconfig_fd = SharedFD::Open(bootconfig_path, O_RDWR); |
| if (!bootconfig_fd->IsOpen()) { |
| LOG(ERROR) << "Unable to open bootconfig file: " |
| << bootconfig_fd->StrError(); |
| return false; |
| } |
| |
| const std::string bootconfig = |
| android::base::Join(BootconfigArgsFromConfig(config_, instance_), |
| "\n") + |
| "\n"; |
| ssize_t bytesWritten = WriteAll(bootconfig_fd, bootconfig); |
| LOG(DEBUG) << "bootconfig size is " << bytesWritten; |
| if (bytesWritten != bootconfig.size()) { |
| LOG(ERROR) << "Failed to write contents of bootconfig to \"" |
| << bootconfig_path << "\""; |
| return false; |
| } |
| LOG(DEBUG) << "Bootconfig parameters from vendor boot image and config are " |
| << ReadFile(bootconfig_path); |
| |
| if (bootconfig_fd->Truncate(bytesWritten) != 0) { |
| LOG(ERROR) << "`truncate --size=" << bytesWritten << " bytes " |
| << bootconfig_path << "` failed:" << bootconfig_fd->StrError(); |
| return false; |
| } |
| |
| if (config_.vm_manager() != Gem5Manager::name()) { |
| bootconfig_fd->Close(); |
| const off_t bootconfig_size_bytes = AlignToPowerOf2( |
| MAX_AVB_METADATA_SIZE + bytesWritten, PARTITION_SIZE_SHIFT); |
| |
| auto avbtool_path = HostBinaryPath("avbtool"); |
| Command bootconfig_hash_footer_cmd(avbtool_path); |
| bootconfig_hash_footer_cmd.AddParameter("add_hash_footer"); |
| bootconfig_hash_footer_cmd.AddParameter("--image"); |
| bootconfig_hash_footer_cmd.AddParameter(bootconfig_path); |
| bootconfig_hash_footer_cmd.AddParameter("--partition_size"); |
| bootconfig_hash_footer_cmd.AddParameter(bootconfig_size_bytes); |
| bootconfig_hash_footer_cmd.AddParameter("--partition_name"); |
| bootconfig_hash_footer_cmd.AddParameter("bootconfig"); |
| bootconfig_hash_footer_cmd.AddParameter("--key"); |
| bootconfig_hash_footer_cmd.AddParameter( |
| DefaultHostArtifactsPath("etc/cvd_avb_testkey.pem")); |
| bootconfig_hash_footer_cmd.AddParameter("--algorithm"); |
| bootconfig_hash_footer_cmd.AddParameter("SHA256_RSA4096"); |
| int success = bootconfig_hash_footer_cmd.Start().Wait(); |
| if (success != 0) { |
| LOG(ERROR) << "Unable to run append hash footer. Exited with status " |
| << success; |
| return false; |
| } |
| } else { |
| const off_t bootconfig_size_bytes_gem5 = AlignToPowerOf2( |
| bytesWritten, PARTITION_SIZE_SHIFT); |
| bootconfig_fd->Truncate(bootconfig_size_bytes_gem5); |
| bootconfig_fd->Close(); |
| } |
| return true; |
| } |
| |
| const CuttlefishConfig& config_; |
| const CuttlefishConfig::InstanceSpecific& instance_; |
| }; |
| |
| class GeneratePersistentVbmeta : public SetupFeature { |
| public: |
| INJECT(GeneratePersistentVbmeta( |
| const CuttlefishConfig& config, |
| const CuttlefishConfig::InstanceSpecific& instance, |
| InitBootloaderEnvPartition& bootloader_env, |
| GeneratePersistentBootconfig& bootconfig)) |
| : config_(config), |
| instance_(instance), |
| bootloader_env_(bootloader_env), |
| bootconfig_(bootconfig) {} |
| |
| // SetupFeature |
| std::string Name() const override { |
| return "GeneratePersistentVbmeta"; |
| } |
| bool Enabled() const override { |
| return (!config_.protected_vm()); |
| } |
| |
| private: |
| std::unordered_set<SetupFeature*> Dependencies() const override { |
| return { |
| static_cast<SetupFeature*>(&bootloader_env_), |
| static_cast<SetupFeature*>(&bootconfig_), |
| }; |
| } |
| |
| bool Setup() override { |
| auto avbtool_path = HostBinaryPath("avbtool"); |
| Command vbmeta_cmd(avbtool_path); |
| vbmeta_cmd.AddParameter("make_vbmeta_image"); |
| vbmeta_cmd.AddParameter("--output"); |
| vbmeta_cmd.AddParameter(instance_.vbmeta_path()); |
| vbmeta_cmd.AddParameter("--algorithm"); |
| vbmeta_cmd.AddParameter("SHA256_RSA4096"); |
| vbmeta_cmd.AddParameter("--key"); |
| vbmeta_cmd.AddParameter( |
| DefaultHostArtifactsPath("etc/cvd_avb_testkey.pem")); |
| |
| vbmeta_cmd.AddParameter("--chain_partition"); |
| vbmeta_cmd.AddParameter("uboot_env:1:" + |
| DefaultHostArtifactsPath("etc/cvd.avbpubkey")); |
| |
| if (config_.bootconfig_supported()) { |
| vbmeta_cmd.AddParameter("--chain_partition"); |
| vbmeta_cmd.AddParameter("bootconfig:2:" + |
| DefaultHostArtifactsPath("etc/cvd.avbpubkey")); |
| } |
| |
| bool success = vbmeta_cmd.Start().Wait(); |
| if (success != 0) { |
| LOG(ERROR) << "Unable to create persistent vbmeta. Exited with status " |
| << success; |
| return false; |
| } |
| |
| if (FileSize(instance_.vbmeta_path()) > VBMETA_MAX_SIZE) { |
| LOG(ERROR) << "Generated vbmeta - " << instance_.vbmeta_path() |
| << " is larger than the expected " << VBMETA_MAX_SIZE |
| << ". Stopping."; |
| return false; |
| } |
| if (FileSize(instance_.vbmeta_path()) != VBMETA_MAX_SIZE) { |
| auto fd = SharedFD::Open(instance_.vbmeta_path(), O_RDWR); |
| if (!fd->IsOpen() || fd->Truncate(VBMETA_MAX_SIZE) != 0) { |
| LOG(ERROR) << "`truncate --size=" << VBMETA_MAX_SIZE << " " |
| << instance_.vbmeta_path() << "` " |
| << "failed: " << fd->StrError(); |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| const CuttlefishConfig& config_; |
| const CuttlefishConfig::InstanceSpecific& instance_; |
| InitBootloaderEnvPartition& bootloader_env_; |
| GeneratePersistentBootconfig& bootconfig_; |
| }; |
| |
| class InitializeMetadataImage : public SetupFeature { |
| public: |
| INJECT(InitializeMetadataImage()) {} |
| |
| // SetupFeature |
| std::string Name() const override { return "InitializeMetadataImage"; } |
| bool Enabled() const override { return true; } |
| |
| private: |
| std::unordered_set<SetupFeature*> Dependencies() const override { return {}; } |
| Result<void> ResultSetup() override { |
| if (FileExists(FLAGS_metadata_image)) { |
| return {}; |
| } |
| |
| CF_EXPECT(CreateBlankImage(FLAGS_metadata_image, |
| FLAGS_blank_metadata_image_mb, "none"), |
| "Failed to create \"" << FLAGS_metadata_image << "\" with size " |
| << FLAGS_blank_metadata_image_mb); |
| return {}; |
| } |
| }; |
| |
| class InitializeAccessKregistryImage : public SetupFeature { |
| public: |
| INJECT(InitializeAccessKregistryImage( |
| const CuttlefishConfig& config, |
| const CuttlefishConfig::InstanceSpecific& instance)) |
| : config_(config), instance_(instance) {} |
| |
| // SetupFeature |
| std::string Name() const override { return "InitializeAccessKregistryImage"; } |
| bool Enabled() const override { return !config_.protected_vm(); } |
| |
| private: |
| std::unordered_set<SetupFeature*> Dependencies() const override { return {}; } |
| Result<void> ResultSetup() override { |
| auto access_kregistry = instance_.access_kregistry_path(); |
| if (FileExists(access_kregistry)) { |
| return {}; |
| } |
| CF_EXPECT(CreateBlankImage(access_kregistry, 2 /* mb */, "none"), |
| "Failed to create \"" << access_kregistry << "\""); |
| return {}; |
| } |
| |
| const CuttlefishConfig& config_; |
| const CuttlefishConfig::InstanceSpecific& instance_; |
| }; |
| |
| class InitializeHwcomposerPmemImage : public SetupFeature { |
| public: |
| INJECT(InitializeHwcomposerPmemImage( |
| const CuttlefishConfig& config, |
| const CuttlefishConfig::InstanceSpecific& instance)) |
| : config_(config), instance_(instance) {} |
| |
| // SetupFeature |
| std::string Name() const override { return "InitializeHwcomposerPmemImage"; } |
| bool Enabled() const override { return !config_.protected_vm(); } |
| |
| private: |
| std::unordered_set<SetupFeature*> Dependencies() const override { return {}; } |
| Result<void> ResultSetup() override { |
| if (FileExists(instance_.hwcomposer_pmem_path())) { |
| return {}; |
| } |
| CF_EXPECT( |
| CreateBlankImage(instance_.hwcomposer_pmem_path(), 2 /* mb */, "none"), |
| "Failed creating \"" << instance_.hwcomposer_pmem_path() << "\""); |
| return {}; |
| } |
| |
| const CuttlefishConfig& config_; |
| const CuttlefishConfig::InstanceSpecific& instance_; |
| }; |
| |
| class InitializePstore : public SetupFeature { |
| public: |
| INJECT(InitializePstore(const CuttlefishConfig& config, |
| const CuttlefishConfig::InstanceSpecific& instance)) |
| : config_(config), instance_(instance) {} |
| |
| // SetupFeature |
| std::string Name() const override { return "InitializePstore"; } |
| bool Enabled() const override { return !config_.protected_vm(); } |
| |
| private: |
| std::unordered_set<SetupFeature*> Dependencies() const override { return {}; } |
| Result<void> ResultSetup() override { |
| if (FileExists(instance_.pstore_path())) { |
| return {}; |
| } |
| |
| CF_EXPECT(CreateBlankImage(instance_.pstore_path(), 2 /* mb */, "none"), |
| "Failed to create \"" << instance_.pstore_path() << "\""); |
| return {}; |
| } |
| |
| const CuttlefishConfig& config_; |
| const CuttlefishConfig::InstanceSpecific& instance_; |
| }; |
| |
| class InitializeSdCard : public SetupFeature { |
| public: |
| INJECT(InitializeSdCard(const CuttlefishConfig& config, |
| const CuttlefishConfig::InstanceSpecific& instance)) |
| : config_(config), instance_(instance) {} |
| |
| // SetupFeature |
| std::string Name() const override { return "InitializeSdCard"; } |
| bool Enabled() const override { |
| return FLAGS_use_sdcard && !config_.protected_vm(); |
| } |
| |
| private: |
| std::unordered_set<SetupFeature*> Dependencies() const override { return {}; } |
| Result<void> ResultSetup() override { |
| if (FileExists(instance_.sdcard_path())) { |
| return {}; |
| } |
| CF_EXPECT(CreateBlankImage(instance_.sdcard_path(), |
| FLAGS_blank_sdcard_image_mb, "sdcard"), |
| "Failed to create \"" << instance_.sdcard_path() << "\""); |
| return {}; |
| } |
| |
| const CuttlefishConfig& config_; |
| const CuttlefishConfig::InstanceSpecific& instance_; |
| }; |
| |
| class InitializeFactoryResetProtected : public SetupFeature { |
| public: |
| INJECT(InitializeFactoryResetProtected( |
| const CuttlefishConfig& config, |
| const CuttlefishConfig::InstanceSpecific& instance)) |
| : config_(config), instance_(instance) {} |
| |
| // SetupFeature |
| std::string Name() const override { return "InitializeSdCard"; } |
| bool Enabled() const override { return !config_.protected_vm(); } |
| |
| private: |
| std::unordered_set<SetupFeature*> Dependencies() const override { return {}; } |
| Result<void> ResultSetup() override { |
| auto frp = instance_.factory_reset_protected_path(); |
| if (FileExists(frp)) { |
| return {}; |
| } |
| CF_EXPECT(CreateBlankImage(frp, 1 /* mb */, "none"), |
| "Failed to create \"" << frp << "\""); |
| return {}; |
| } |
| |
| const CuttlefishConfig& config_; |
| const CuttlefishConfig::InstanceSpecific& instance_; |
| }; |
| |
| class InitializeInstanceCompositeDisk : public SetupFeature { |
| public: |
| INJECT(InitializeInstanceCompositeDisk( |
| const CuttlefishConfig& config, |
| const CuttlefishConfig::InstanceSpecific& instance, |
| InitializeFactoryResetProtected& frp, |
| GeneratePersistentVbmeta& vbmeta)) |
| : config_(config), |
| instance_(instance), |
| frp_(frp), |
| vbmeta_(vbmeta) {} |
| |
| std::string Name() const override { |
| return "InitializeInstanceCompositeDisk"; |
| } |
| bool Enabled() const override { return true; } |
| |
| private: |
| std::unordered_set<SetupFeature*> Dependencies() const override { |
| return { |
| static_cast<SetupFeature*>(&frp_), |
| static_cast<SetupFeature*>(&vbmeta_), |
| }; |
| } |
| Result<void> ResultSetup() override { |
| auto ipath = [this](const std::string& path) -> std::string { |
| return instance_.PerInstancePath(path.c_str()); |
| }; |
| auto persistent_disk_builder = |
| DiskBuilder() |
| .Partitions(persistent_composite_disk_config(config_, instance_)) |
| .VmManager(config_.vm_manager()) |
| .CrosvmPath(config_.crosvm_binary()) |
| .ConfigPath(ipath("persistent_composite_disk_config.txt")) |
| .HeaderPath(ipath("persistent_composite_gpt_header.img")) |
| .FooterPath(ipath("persistent_composite_gpt_footer.img")) |
| .CompositeDiskPath(instance_.persistent_composite_disk_path()) |
| .ResumeIfPossible(FLAGS_resume); |
| |
| CF_EXPECT(persistent_disk_builder.BuildCompositeDiskIfNecessary()); |
| return {}; |
| } |
| |
| const CuttlefishConfig& config_; |
| const CuttlefishConfig::InstanceSpecific& instance_; |
| InitializeFactoryResetProtected& frp_; |
| GeneratePersistentVbmeta& vbmeta_; |
| }; |
| |
| class VbmetaEnforceMinimumSize : public SetupFeature { |
| public: |
| INJECT(VbmetaEnforceMinimumSize()) {} |
| |
| std::string Name() const override { return "VbmetaEnforceMinimumSize"; } |
| bool Enabled() const override { return true; } |
| |
| private: |
| std::unordered_set<SetupFeature*> Dependencies() const override { return {}; } |
| Result<void> ResultSetup() override { |
| // libavb expects to be able to read the maximum vbmeta size, so we must |
| // provide a partition which matches this or the read will fail |
| for (const auto& vbmeta_image : |
| {FLAGS_vbmeta_image, FLAGS_vbmeta_system_image}) { |
| if (FileSize(vbmeta_image) != VBMETA_MAX_SIZE) { |
| auto fd = SharedFD::Open(vbmeta_image, O_RDWR); |
| CF_EXPECT(fd->IsOpen(), "Could not open \"" << vbmeta_image << "\": " |
| << fd->StrError()); |
| CF_EXPECT(fd->Truncate(VBMETA_MAX_SIZE) == 0, |
| "`truncate --size=" << VBMETA_MAX_SIZE << " " << vbmeta_image |
| << "` failed: " << fd->StrError()); |
| } |
| } |
| return {}; |
| } |
| }; |
| |
| class BootloaderPresentCheck : public SetupFeature { |
| public: |
| INJECT(BootloaderPresentCheck()) {} |
| |
| std::string Name() const override { return "BootloaderPresentCheck"; } |
| bool Enabled() const override { return true; } |
| |
| private: |
| std::unordered_set<SetupFeature*> Dependencies() const override { return {}; } |
| Result<void> ResultSetup() override { |
| CF_EXPECT(FileHasContent(FLAGS_bootloader), |
| "File not found: " << FLAGS_bootloader); |
| return {}; |
| } |
| }; |
| |
| static fruit::Component<> DiskChangesComponent(const FetcherConfig* fetcher, |
| const CuttlefishConfig* config) { |
| return fruit::createComponent() |
| .bindInstance(*fetcher) |
| .bindInstance(*config) |
| .addMultibinding<SetupFeature, InitializeMetadataImage>() |
| .addMultibinding<SetupFeature, BootImageRepacker>() |
| .addMultibinding<SetupFeature, VbmetaEnforceMinimumSize>() |
| .addMultibinding<SetupFeature, BootloaderPresentCheck>() |
| .addMultibinding<SetupFeature, Gem5ImageUnpacker>() |
| .install(FixedMiscImagePathComponent, &FLAGS_misc_image) |
| .install(InitializeMiscImageComponent) |
| .install(FixedDataImagePathComponent, &FLAGS_data_image) |
| .install(InitializeDataImageComponent) |
| // Create esp if necessary |
| .install(InitializeEspImageComponent, &FLAGS_otheros_esp_image, |
| &FLAGS_otheros_kernel_path, &FLAGS_otheros_initramfs_path, |
| &FLAGS_otheros_root_image, config) |
| .install(SuperImageRebuilderComponent, &FLAGS_super_image); |
| } |
| |
| static fruit::Component<> DiskChangesPerInstanceComponent( |
| const FetcherConfig* fetcher, const CuttlefishConfig* config, |
| const CuttlefishConfig::InstanceSpecific* instance) { |
| return fruit::createComponent() |
| .bindInstance(*fetcher) |
| .bindInstance(*config) |
| .bindInstance(*instance) |
| .addMultibinding<SetupFeature, InitializeAccessKregistryImage>() |
| .addMultibinding<SetupFeature, InitializeHwcomposerPmemImage>() |
| .addMultibinding<SetupFeature, InitializePstore>() |
| .addMultibinding<SetupFeature, InitializeSdCard>() |
| .addMultibinding<SetupFeature, InitializeFactoryResetProtected>() |
| .addMultibinding<SetupFeature, GeneratePersistentBootconfig>() |
| .addMultibinding<SetupFeature, GeneratePersistentVbmeta>() |
| .addMultibinding<SetupFeature, InitializeInstanceCompositeDisk>() |
| .install(InitBootloaderEnvPartitionComponent); |
| } |
| |
| Result<void> CreateDynamicDiskFiles(const FetcherConfig& fetcher_config, |
| const CuttlefishConfig& config) { |
| // TODO(schuffelen): Unify this with the other injector created in |
| // assemble_cvd.cpp |
| fruit::Injector<> injector(DiskChangesComponent, &fetcher_config, &config); |
| |
| const auto& features = injector.getMultibindings<SetupFeature>(); |
| CF_EXPECT(SetupFeature::RunSetup(features)); |
| |
| for (const auto& instance : config.Instances()) { |
| fruit::Injector<> instance_injector(DiskChangesPerInstanceComponent, |
| &fetcher_config, &config, &instance); |
| const auto& instance_features = |
| instance_injector.getMultibindings<SetupFeature>(); |
| CF_EXPECT(SetupFeature::RunSetup(instance_features), |
| "instance = \"" << instance.instance_name() << "\""); |
| } |
| |
| // Check if filling in the sparse image would run out of disk space. |
| auto existing_sizes = SparseFileSizes(FLAGS_data_image); |
| CF_EXPECT(existing_sizes.sparse_size > 0 || existing_sizes.disk_size > 0, |
| "Unable to determine size of \"" << FLAGS_data_image |
| << "\". Does this file exist?"); |
| auto available_space = AvailableSpaceAtPath(FLAGS_data_image); |
| if (available_space < existing_sizes.sparse_size - existing_sizes.disk_size) { |
| // TODO(schuffelen): Duplicate this check in run_cvd when it can run on a |
| // separate machine |
| return CF_ERR("Not enough space remaining in fs containing \"" |
| << FLAGS_data_image << "\", wanted " |
| << (existing_sizes.sparse_size - existing_sizes.disk_size) |
| << ", got " << available_space); |
| } else { |
| LOG(DEBUG) << "Available space: " << available_space; |
| LOG(DEBUG) << "Sparse size of \"" << FLAGS_data_image |
| << "\": " << existing_sizes.sparse_size; |
| LOG(DEBUG) << "Disk size of \"" << FLAGS_data_image |
| << "\": " << existing_sizes.disk_size; |
| } |
| |
| auto os_disk_builder = OsCompositeDiskBuilder(config); |
| auto built_composite = |
| CF_EXPECT(os_disk_builder.BuildCompositeDiskIfNecessary()); |
| if (built_composite) { |
| for (auto instance : config.Instances()) { |
| if (FileExists(instance.access_kregistry_path())) { |
| CF_EXPECT(CreateBlankImage(instance.access_kregistry_path(), 2 /* mb */, |
| "none"), |
| "Failed for \"" << instance.access_kregistry_path() << "\""); |
| } |
| if (FileExists(instance.hwcomposer_pmem_path())) { |
| CF_EXPECT(CreateBlankImage(instance.hwcomposer_pmem_path(), 2 /* mb */, |
| "none"), |
| "Failed for \"" << instance.hwcomposer_pmem_path() << "\""); |
| } |
| if (FileExists(instance.pstore_path())) { |
| CF_EXPECT(CreateBlankImage(instance.pstore_path(), 2 /* mb */, "none"), |
| "Failed for\"" << instance.pstore_path() << "\""); |
| } |
| } |
| } |
| |
| if (!FLAGS_protected_vm) { |
| for (auto instance : config.Instances()) { |
| os_disk_builder.OverlayPath(instance.PerInstancePath("overlay.img")); |
| CF_EXPECT(os_disk_builder.BuildOverlayIfNecessary()); |
| if (instance.start_ap()) { |
| os_disk_builder.OverlayPath(instance.PerInstancePath("ap_overlay.img")); |
| CF_EXPECT(os_disk_builder.BuildOverlayIfNecessary()); |
| } |
| } |
| } |
| |
| for (auto instance : config.Instances()) { |
| // Check that the files exist |
| for (const auto& file : instance.virtual_disk_paths()) { |
| if (!file.empty()) { |
| CF_EXPECT(FileHasContent(file), "File not found: \"" << file << "\""); |
| } |
| } |
| // Gem5 Simulate per-instance what the bootloader would usually do |
| // Since on other devices this runs every time, just do it here every time |
| if (config.vm_manager() == Gem5Manager::name()) { |
| RepackGem5BootImage( |
| instance.PerInstancePath("initrd.img"), |
| instance.persistent_bootconfig_path(), |
| config.assembly_dir()); |
| } |
| } |
| |
| return {}; |
| } |
| |
| } // namespace cuttlefish |
