build/images/BUILD.gn

# 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.

import("//build/board.gni")
import("//build/compiled_action.gni")
import("//build/component/component_id_index.gni")
import("//build/config.gni")
import("//build/config/clang/clang.gni")
import("//build/config/fuchsia/zircon.gni")
import("//build/dev.gni")
import("//build/images/args.gni")
import("//build/images/boot.gni")
import("//build/images/collect_blob_manifest.gni")
import("//build/images/custom_signing.gni")
import("//build/images/filesystem_limits.gni")
import("//build/images/fvm.gni")
import("//build/images/manifest.gni")
import("//build/images/max_fvm_size.gni")
import("//build/images/pkgfs.gni")
import("//build/images/shell_commands.gni")
import("//build/images/vbmeta.gni")
import("//build/info/info.gni")
import("//build/packages/package_metadata.gni")
import("//build/product.gni")
import("//build/unification/future/images/devmgr_config.gni")
import("//build/unification/zx_host_tool.gni")
import("//build/zbi/zbi.gni")
import("//build/zbi/zbi_input.gni")
import("//src/sys/component_index/component_index.gni")
import("//src/sys/pkg/bin/pm/pm.gni")

recovery_is_zedboot =
    get_label_info(recovery_label, "label_with_toolchain") ==
    get_label_info("//build/images/zedboot", "label_with_toolchain")

# update_manifest is for the "update.manifest" target below.
update_manifest = []

# Dependencies for all image targets referenced by paver_targets, i.e., the
# images needed by the generated pave scripts.
default_image_deps = []

board_name_file = "$root_build_dir/board_name"
write_file(board_name_file, "${board_name}")

group("meta_packages") {
  visibility = [ ":*" ]
  testonly = fuchsia_zbi_testonly
  public_deps = meta_package_labels
}

group("base_packages") {
  testonly = base_cache_packages_testonly
  visibility = [ ":*" ]
  public_deps = [ "//:additional_base_packages" ]
}

group("cache_packages") {
  testonly = base_cache_packages_testonly
  visibility = [ ":*" ]
  public_deps = [ "//:additional_cache_packages" ]
}

group("universe_packages") {
  testonly = fuchsia_zbi_testonly
  visibility = [ ":*" ]
  public_deps = [
    ":base_packages",
    ":cache_packages",
    "//:additional_universe_packages",
  ]
}

group("packages") {
  testonly = true
  public_deps = [
    ":meta_packages",
    ":universe_packages",
  ]
}

template("package_list") {
  generate_package_metadata(target_name) {
    testonly = true
    forward_variables_from(invoker,
                           [
                             "deps",
                             "public_deps",
                             "visibility",
                           ])

    data_keys = [ "package_names" ]
    outputs = [ "$root_out_dir/$target_name" ]
  }
}

package_list("base_packages.list") {
  visibility = [ ":*" ]
  deps = [
    ":base_packages",
    ":meta_packages",
  ]
}

package_list("cache_packages.list") {
  visibility = [ ":*" ]
  deps = [ ":cache_packages" ]
}

package_list("universe_packages.list") {
  visibility = [ ":*" ]
  deps = [ ":universe_packages" ]
}

group("package_lists") {
  testonly = true
  visibility = [ ":*" ]

  deps = [
    ":all_package_manifests.list",
    ":base_packages.list",
    ":cache_packages.list",
    ":universe_packages.list",
  ]
}

config_package("config-data") {
  testonly = fuchsia_zbi_testonly
  visibility = [ ":*" ]
  deps = [
    ":component_id_index_config-config-data",
    ":universe_packages",
  ]
}

shell_commands("shell-commands") {
  testonly = fuchsia_zbi_testonly
  visibility = [ ":*" ]
  deps = [ ":universe_packages" ]
}

###
### Fuchsia system image.  This aggregates contributions from all the
### package() targets enabled in the build.
###

monolith_meta_far_merkle_index =
    "$target_out_dir/monolith_meta_far_merkle_index"
generate_package_metadata("monolith_meta_far_merkle_index") {
  testonly = fuchsia_zbi_testonly
  outputs = [ monolith_meta_far_merkle_index ]
  data_keys = [ "meta_far_merkle_index_entries" ]
  deps = [
    ":base_packages",
    ":meta_packages",
  ]
}

# The pkgsvr index is a manifest mapping `package_name/package_version` to
# the merkleroot of the package's meta.far file.
pkgsvr_index = "$target_out_dir/pkgsvr_index"

action("pkgsvr_index") {
  visibility = [
    ":system_image.manifest",
    ":system_image.manifest.runtime_deps",
    ":system_image.manifest.runtime_deps_generate",
    ":system_image_prime.manifest",
    ":update_packages.manifest",
  ]
  testonly = fuchsia_zbi_testonly
  outputs = [ "$target_out_dir/$target_name" ]
  deps = [ ":monolith_meta_far_merkle_index" ]
  inputs = [ monolith_meta_far_merkle_index ]

  hermetic_deps = false
  script = "//build/images/manifest_content_expand.sh"
  args = [
    rebase_path(monolith_meta_far_merkle_index, root_build_dir),
    rebase_path(outputs[0], root_build_dir),
  ]
}

preinstall_meta_far_merkle_index =
    "$target_out_dir/preinstall_meta_far_merkle_index"
generate_package_metadata("preinstall_meta_far_merkle_index") {
  testonly = fuchsia_zbi_testonly
  outputs = [ preinstall_meta_far_merkle_index ]
  data_keys = [ "meta_far_merkle_index_entries" ]
  deps = [ ":cache_packages" ]
}

#
# The cache index is another manifest mapping `package_name/package_version` to
# the merkleroot of the package's meta.far file, only for cache packages
cache_index = "$target_out_dir/cache_index"

action("cache_index") {
  visibility = [
    ":system_image.manifest",
    ":system_image.manifest.runtime_deps",
    ":system_image.manifest.runtime_deps_generate",
  ]
  testonly = fuchsia_zbi_testonly
  outputs = [ "$target_out_dir/$target_name" ]
  deps = [ ":preinstall_meta_far_merkle_index" ]
  inputs = [ preinstall_meta_far_merkle_index ]

  hermetic_deps = false
  script = "//build/images/manifest_content_expand.sh"
  args = [
    rebase_path(preinstall_meta_far_merkle_index, root_build_dir),
    rebase_path(outputs[0], root_build_dir),
  ]
}

system_image_manifest_args = "system_image.manifest_args"
system_image_manifest_args_path = target_gen_dir + "/system_image.manifest_args"

generated_file(system_image_manifest_args) {
  testonly = fuchsia_zbi_testonly
  outputs = [ system_image_manifest_args_path ]
  data_keys = [ "system_image_rsps" ]
  walk_keys = [ "system_image_barrier" ]
  deps = [
    ":base_packages",
    ":meta_packages",
  ]
  deps += [ "//build/input:system_image" ]
}

# The system_image "package" manifest is everything that appears in /system.
generate_manifest("system_image.manifest") {
  visibility = [ ":*" ]
  testonly = fuchsia_zbi_testonly

  # Now each package() target in the build contributes manifest entries.
  # For system_image packages, these contain binaries that need their
  # references resolved from the auxiliary manifests or /boot (above).
  deps = [ ":" + system_image_manifest_args ]
  sources = [ system_image_manifest_args_path ]
  args = [ "@" + rebase_path(system_image_manifest_args_path, root_build_dir) ]

  args += [ "--entry-manifest=" +
            get_label_info(":$target_name", "label_no_toolchain") ]

  # Add the meta/package JSON file that makes this the "system_image" package.
  json = "system_meta_package.json"
  sources += [ json ]
  args += [ "--entry=meta/package=" + rebase_path(json, root_build_dir) ]

  # Add the static packages (pkgsvr) index.
  deps += [ ":pkgsvr_index" ]
  sources += [ pkgsvr_index ]
  args += [ "--entry=data/static_packages=" +
            rebase_path(pkgsvr_index, root_build_dir) ]

  # Add the cache packages index.
  deps += [ ":cache_index" ]
  sources += [ cache_index ]
  args += [ "--entry=data/cache_packages=" +
            rebase_path(cache_index, root_build_dir) ]

  # Add the allowlist for which non-static packages pkgfs will return.
  sources += [ pkgfs_packages_allowlist ]
  args += [ "--entry=data/pkgfs_packages_non_static_packages_allowlist.txt=" +
            rebase_path(pkgfs_packages_allowlist, root_build_dir) ]
}
system_manifest_outputs = get_target_outputs(":system_image.manifest")

# The prime version of the system_image has an extra "dummy" file.
# The prime images are used to have an alternate known-compatible OTA
# target for integration testing.
action("system_image_prime.manifest") {
  visibility = [ ":*" ]
  testonly = true
  hermetic_deps = false
  script = "manifest.py"
  outputs = [ "$target_out_dir/$target_name" ]

  deps = [ ":system_image.manifest" ]
  sources = system_manifest_outputs + [
              "system_image_prime_meta_package.json",
              "dummy/example.txt",
            ]
  args = [
    "--output",
    rebase_path(outputs[0], root_build_dir),
    "--rewrite",
    "meta/package={target}=" +
        rebase_path("system_image_prime_meta_package.json", root_build_dir),
    "--manifest",
    rebase_path(system_manifest_outputs[0], root_build_dir),
    "--reset-rewrite",
    "--entry",
    "data/dummy/example.txt=" +
        rebase_path("dummy/example.txt", root_build_dir),
  ]
}

# Generate, sign, and seal the system_image package file.
pm_build("system_image.meta") {
  package_name = "system_image"
  visibility = [ ":*" ]
  testonly = fuchsia_zbi_testonly
  manifest = ":system_image.manifest"
}

# Now generate the blob manifest.  This lists all the source files
# that need to go into the blobfs image.  That is everything from the
# system_image manifest, everything from each package manifest, and
# all the synthesized meta.far files.
blob_manifest = "$target_out_dir/blob.manifest"

collect_blob_manifest("blob.manifest") {
  testonly = true
  visibility = [ ":*" ]
  outputs = [ blob_manifest ]
  deps = [
    ":base_packages",
    ":cache_packages",
    ":meta_packages",
    ":system_image.meta",
    pkgfs_package_label,
  ]
  if (product_include_updates_in_blobfs) {
    deps += [ ":update.meta" ]
  }
}

blob_image_path = "$target_out_dir/blob.blk"
rebased_blob_image_path = rebase_path(blob_image_path, root_build_dir)
blob_size_list = "$root_build_dir/blobs.json"

# Pack up all the blobs!
compiled_action("blob.blk") {
  visibility = [ ":*" ]
  testonly = true
  deps = [ ":blob.manifest" ]
  outputs = [
    blob_image_path,
    blob_size_list,
  ]
  depfile = blob_image_path + ".d"
  inputs = [ blob_manifest ]
  tool = "//zircon/tools/blobfs"
  args = [
    "--depfile",
    "--json-output",
    rebase_path(blob_size_list, root_build_dir),
  ]
  if (compress_blobs) {
    args += [ "--compress" ]
  }
  args += [
    rebase_path(blob_image_path, root_build_dir),
    "create",
    "--manifest",
    rebase_path(blob_manifest, root_build_dir),
    "--blob_layout_format",
    blob_layout_format,
  ]

  metadata = {
    images = [
      {
        name = "blob"
        path = rebased_blob_image_path
        type = "blk"
      },
    ]
    image_paths = [ "IMAGE_BLOB_RAW=$rebased_blob_image_path" ]
  }
}
default_image_deps += [ ":blob.blk" ]

# The prime images are used to have an alternate known-compatible OTA
# target for integration testing.
pm_build("system_image_prime.meta") {
  package_name = "system_image_prime"
  visibility = [ ":*" ]
  testonly = true
  manifest = ":system_image_prime.manifest"
}

###
### Zircon Boot Images
###

# Used to populate image_paths.sh with the right values to point to the QEMU kernel.
group("qemu-kernel") {
  if (target_cpu == "x64") {
    _qemu_kernel_target = "//zircon/kernel/target/pc/multiboot"
    _qemu_kernel_file = "$root_build_dir/multiboot.bin"
  } else if (target_cpu == "arm64") {
    _qemu_kernel_target = "//zircon/kernel/target/arm64/boot-shim:qemu"
    _qemu_kernel_file = "$root_build_dir/qemu-boot-shim.bin"
  } else {
    assert(false, "Unsupported target cpu: $target_cpu")
  }
  metadata = {
    image_paths = [ "IMAGE_QEMU_KERNEL_RAW=" +
                    rebase_path(_qemu_kernel_file, root_build_dir) ]
  }
  deps = [ _qemu_kernel_target ]
}

default_image_deps += [ ":qemu-kernel" ]

# Generate the /boot/config/devmgr file.  This looks like a kernel command
# line file, but is read by devmgr (in addition to kernel command line
# arguments), not by the kernel or boot loader.
action("devmgr_config.txt") {
  visibility = [
    ":devmgr_config",
    ":devmgr_config_prime.txt",
    ":fuchsia",
    ":fuchsia.vbmeta",
    ":fuchsia.vbmeta__vb_desc",
    ":fuchsia.vbmeta__zbi_props",
  ]
  testonly = fuchsia_zbi_testonly
  hermetic_deps = false
  script = "manifest.py"
  outputs = [ "$target_out_dir/devmgr_config.txt" ]
  args = [ "--output=" + rebase_path(outputs[0], root_build_dir) ]
  sources = []
  deps = [ ":system_image.manifest" ]

  pkgfs = "bin/" + pkgfs_binary_name
  pkgfs_label = pkgfs_package_label
  pkgfs_pkg_out_dir = get_label_info(pkgfs_label, "target_out_dir") + "/" +
                      get_label_info(pkgfs_label, "name")
  pkgfs_blob_manifest = "$pkgfs_pkg_out_dir/meta/contents"
  system_image_merkleroot = "$target_out_dir/system_image.meta/meta.far.merkle"

  deps += [
    ":system_image.meta",
    "//build/info:latest-commit-date",
    pkgfs_label,
  ]
  sources += [
    pkgfs_blob_manifest,
    system_image_merkleroot,
  ]

  args += [ "--entry=devmgr.require-system=true" ]

  # Add the pkgfs command line, embedding the merkleroot of the system image.
  args += [
    "--contents",
    "--rewrite=*=zircon.system.pkgfs.cmd={target}+{source}",
    "--entry=${pkgfs}=" + rebase_path(system_image_merkleroot, root_build_dir),
    "--no-contents",
    "--reset-rewrite",
  ]

  # Embed the pkgfs blob manifest with the "zircon.system.pkgfs.file."
  # prefix on target file names.
  args += [
    "--rewrite=*=zircon.system.pkgfs.file.{target}={source}",
    "--manifest=" + rebase_path(pkgfs_blob_manifest, root_build_dir),
    "--reset-rewrite",
  ]

  # Add the backstop UTC value from the integration repo latest commit
  args += [
    "--contents",
    "--entry=clock.backstop=" +
        rebase_path(build_info_files.minimum_utc_stamp, root_build_dir),
    "--no-contents",
    "--reset-rewrite",
  ]

  foreach(entry, devmgr_config) {
    args += [ "--entry=$entry" ]
  }
}

devmgr_config("devmgr_config") {
  testonly = fuchsia_zbi_testonly
  label = ":devmgr_config.txt"
}

# Generate the prime /boot/config/devmgr file. Points to system_image_prime
# instead of system_image
# The prime images are used to have an alternate known-compatible OTA
# target for integration testing.
action("devmgr_config_prime.txt") {
  visibility = [
    ":devmgr_config_prime",
    ":fuchsia_prime",
    ":fuchsia_prime.vbmeta",
    ":fuchsia_prime.vbmeta__vb_desc",
    ":fuchsia_prime.vbmeta__zbi_props",
  ]
  testonly = true
  hermetic_deps = false
  script = "manifest.py"
  outputs = [ "$target_out_dir/devmgr_config_prime.txt" ]
  args = [ "--output=" + rebase_path(outputs[0], root_build_dir) ]
  deps = [ ":devmgr_config.txt" ]
  devmgr_config_outputs = get_target_outputs(":devmgr_config.txt")
  sources = devmgr_config_outputs
  args += [
    "--exclude",
    "zircon.system.pkgfs.cmd",
    "--manifest",
    rebase_path(devmgr_config_outputs[0], root_build_dir),
    "--reset-exclude",
  ]

  pkgfs = "bin/" + pkgfs_binary_name
  system_image_merkleroot =
      "$target_out_dir/system_image_prime.meta/meta.far.merkle"

  deps += [ ":system_image_prime.meta" ]
  sources += [ system_image_merkleroot ]

  # Add the pkgfs command line, embedding the merkleroot of the system image.
  args += [
    "--contents",
    "--rewrite=*=zircon.system.pkgfs.cmd={target}+{source}",
    "--entry=${pkgfs}=" + rebase_path(system_image_merkleroot, root_build_dir),
    "--no-contents",
    "--reset-rewrite",
  ]
}

devmgr_config("devmgr_config_prime") {
  label = ":devmgr_config_prime.txt"
  testonly = true
}

# The main bootable image, which requires `blob.blk` to appear on some
# attached storage device at runtime.
zbi("fuchsia") {
  testonly = fuchsia_zbi_testonly

  output_dir = root_out_dir

  deps = [
    "//build/input:bootfs",
    "//build/unification/zbi:kernel",
  ]

  if (!include_devmgr_config_in_vbmeta) {
    deps += [ ":devmgr_config" ]
  }

  if (check_production_eligibility) {
    # Check no rule that depends on non_production_tag is included in the final
    # ZBI composition. This dependency might be set on rule that does not have
    # testonly=true but is only suitable for userdebug, but not user build.
    # We set check_production_eligibility to true only for user build.
    assert_no_deps = [ "//build/validate:non_production_tag" ]
  }

  metadata = {
    images = [
      {
        name = "zircon-a"
        path = "fuchsia.zbi"
        type = "zbi"

        archive = true
        bootserver_pave = []

        # TODO(fxbug.dev/31931): we want to reduce the usage of mexec, but currently we
        # do not have sufficient boot control on x64.
        if (target_cpu == "x64") {
          bootserver_pave += [ "--boot" ]
        }
        if (custom_signing_script == "" && !use_vboot) {
          bootserver_pave += [
            "--zircona",
            # TODO(fxbug.dev/32475): `dm reboot-recovery` boots from zircon-b instead of
            # zircon-r, so for now zedboot is being paved to this slot.
            # "--zirconb",
          ]

          fastboot_flash = []
          if (zircon_a_partition != "") {
            fastboot_flash += [ zircon_a_partition ]
          }
          if (zircon_b_partition != "") {
            fastboot_flash += [ zircon_b_partition ]
          }
        }
      },
    ]

    image_paths = [
      "IMAGE_ZIRCONA_ZBI=fuchsia.zbi",

      # TODO(mcgrathr): The complete ZBI can be used with a separate
      # kernel too, the kernel image in it will just be ignored.  So
      # just use the primary ZBI for this until all uses are
      # converted to using the ZBI alone.  Then remove this as
      # IMAGE_BOOT_RAM variable should no longer be in use.
      "IMAGE_BOOT_RAM=fuchsia.zbi",
    ]
  }
}
default_image_deps += [ ":fuchsia" ]

if (dev_fuchsia_zbi_kernel_cmdline_golden != "") {
  action("fuchsia_zbi_verify") {
    testonly = true

    script = "//build/zbi/verify_zbi_kernel_cmdline.py"
    stamp_file = "$target_gen_dir/$target_name.verified"
    scrutiny_target = "//src/security/scrutiny/bin($host_toolchain)"
    scrutiny_tool =
        get_label_info(scrutiny_target, "root_out_dir") + "/scrutiny"

    inputs = [
      scrutiny_tool,
      dev_fuchsia_zbi_kernel_cmdline_golden,
      "$root_out_dir/fuchsia.zbi",
    ]

    outputs = [ stamp_file ]

    args = [
      "--zbi-file",
      rebase_path(inputs[2], root_build_dir),
      "--kernel-cmdline-golden-file",
      rebase_path(dev_fuchsia_zbi_kernel_cmdline_golden, root_build_dir),
      "--scrutiny",
      rebase_path(scrutiny_tool, root_build_dir),
      "--fuchsia-dir",
      rebase_path("//", root_build_dir),
      "--stamp",
      rebase_path(stamp_file, root_build_dir),
    ]

    deps = [
      ":fuchsia",
      scrutiny_target,
    ]
  }

  default_image_deps += [ ":fuchsia_zbi_verify" ]
}

if (!use_vboot && custom_signing_script == "") {
  update_manifest += [
    {
      target = "zbi"
      deps = [ ":fuchsia" ]
    },
  ]
}

# ZBI tool JSON output doesn't record paths of input files so there's no easy
# way to find out where each of the binaries in bootfs entry came from. Rather,
# we extract the ZBI and then pass this directory as an input to the elfinfo.py
# script which computes the ELF sizes.
#
# TODO(phosek): Try to come up with a more efficient solution that does not
# require extract the ZBI.

fuchsia_zbi_json = "$target_out_dir/fuchsia.zbi.json"
fuchsia_zbi_bootfs_dir = "$target_out_dir/fuchsia.zbi/bootfs"

zx_host_tool_action("extract_bootfs") {
  visibility = [ ":elf_sizes.json" ]
  testonly = true
  tool = "//zircon/tools/zbi"
  inputs = [ "$root_out_dir/fuchsia.zbi" ]
  outputs = [ fuchsia_zbi_json ]
  deps = [ ":fuchsia" ]
  args = [
    "--extract",
    "--output-dir=" + rebase_path(fuchsia_zbi_bootfs_dir, root_build_dir),
    "--json-output=" + rebase_path(fuchsia_zbi_json, root_build_dir),
    rebase_path(inputs[0], root_out_dir),
  ]
}

action("elf_sizes.json") {
  testonly = true
  hermetic_deps = false
  script = "elfinfo.py"
  deps = [
    ":blob.blk",
    ":extract_bootfs",
  ]
  sources = [
    blob_size_list,
    fuchsia_zbi_json,
  ]
  outputs = [ "$root_build_dir/$target_name" ]
  args = [
    "--sizes",
    rebase_path(outputs[0], root_build_dir),
    "--blobs",
    rebase_path(blob_size_list, root_build_dir),
    "--zbi",
    rebase_path(fuchsia_zbi_json, root_build_dir),
    "--bootfs-dir",
    rebase_path(fuchsia_zbi_bootfs_dir, root_build_dir),
  ]
}

# Generate the prime fuchsia.zbi.
# The prime images are used to have an alternate known-compatible OTA
# target for integration testing.
zbi("fuchsia_prime") {
  testonly = true

  output_dir = root_out_dir

  deps = [
    "//build/input:bootfs",
    "//build/unification/zbi:kernel",
  ]

  if (!include_devmgr_config_in_vbmeta) {
    deps += [ ":devmgr_config_prime" ]
  }
}

unsigned_zbi_prime = {
  dep = ":fuchsia_prime"
  updater = "zbi"
}

if (custom_signing_script != "") {
  custom_signed_zbi("signed") {
    output_name = "fuchsia.zbi"
    testonly = true
    deps = [ ":fuchsia" ]
    zbi_outputs = get_target_outputs(":fuchsia")
    zbi = [ zbi_outputs[0] ]
    metadata = {
      images = [
        {
          archive = true
          bootserver_pave = [ "--zircona" ]
          name = "zircon-a.signed"
          path = "$output_name.signed"
          type = "zbi.signed"

          fastboot_flash = []
          if (zircon_a_partition != "") {
            fastboot_flash += [ zircon_a_partition ]
          }
          if (zircon_b_partition != "") {
            fastboot_flash += [ zircon_b_partition ]
          }
        },
      ]
      image_paths = [ "IMAGE_ZIRCONA_SIGNEDZBI=$output_name.signed" ]
    }
  }
} else if (use_vboot) {
  # ChromeOS vboot images.
  vboot("signed") {
    testonly = true
    output_name = "fuchsia.zbi"
    deps = [ ":fuchsia" ]

    metadata = {
      images = [
        {
          archive = true
          bootserver_pave = [ "--zircona" ]
          name = "zircon-a.signed"
          path = "$output_name.vboot"
          type = "zbi.signed"

          fastboot_flash = []
          if (zircon_a_partition != "") {
            fastboot_flash += [ zircon_a_partition ]
          }
          if (zircon_b_partition != "") {
            fastboot_flash += [ zircon_b_partition ]
          }
        },
      ]
      image_paths = [ "IMAGE_ZIRCONA_SIGNEDZBI=$output_name.signed" ]
    }
  }
}

if (custom_signing_script != "" || use_vboot) {
  default_image_deps += [ ":signed" ]
  update_manifest += [
    {
      target = "zbi.signed"
      deps = [ ":signed" ]
    },
  ]
}

# Sign fuchsia_prime.zbi, if neccessary.
# The *_prime images are used to have an alternate
# known-compatible OTA target for integration testing.
if (custom_signing_script != "") {
  custom_signed_zbi("fuchsia_prime_signed") {
    output_name = "fuchsia_prime.zbi"
    testonly = true
    deps = [ ":fuchsia_prime" ]
    zbi_outputs = get_target_outputs(":fuchsia_prime")
    zbi = [ zbi_outputs[0] ]
  }
  zbi_prime = {
    dep = ":fuchsia_prime_signed"
    updater = "zbi.signed"
  }
  not_needed([ "unsigned_zbi_prime" ])
} else if (use_vboot) {
  # ChromeOS vboot images.
  vboot("fuchsia_prime_signed") {
    testonly = true
    output_name = "fuchsia_prime.zbi"
    deps = [ ":fuchsia_prime" ]
  }

  zbi_prime = {
    dep = ":fuchsia_prime_signed"
    updater = "zbi.signed"
  }
  not_needed([ "unsigned_zbi_prime" ])
} else {
  zbi_prime = unsigned_zbi_prime
}

if (use_vbmeta) {
  vbmeta("fuchsia.vbmeta") {
    output_name = "fuchsia"
    testonly = true
    if (custom_signing_script != "") {
      deps = [ ":signed" ]
      zbi_outputs = get_target_outputs(":signed")
      zbi = [ zbi_outputs[0] ]
    } else {
      deps = [ ":fuchsia" ]
      zbi_outputs = get_target_outputs(":fuchsia")
      zbi = [ zbi_outputs[0] ]
    }
    if (include_devmgr_config_in_vbmeta) {
      deps += [ ":devmgr_config.txt" ]

      boot_args_file = get_target_outputs(":devmgr_config.txt")

      # expecting a single file
      assert([ boot_args_file[0] ] == boot_args_file,
             "expect a single output file form 'devmgr_config.txt' target")

      prop_from_file = [
        {
          # zbi item type w/o ZBI_TYPE_ prefix
          type = "IMAGE_ARGS"
          file = boot_args_file[0]
        },
      ]
    }

    metadata = {
      images = [
        {
          archive = true
          name = "zircon-a"
          path = "fuchsia.vbmeta"
          type = "vbmeta"

          bootserver_pave = [ "--vbmetaa" ]

          fastboot_flash = []
          if (vbmeta_a_partition != "") {
            fastboot_flash += [ vbmeta_a_partition ]
          }
          if (vbmeta_b_partition != "") {
            fastboot_flash += [ vbmeta_b_partition ]
          }
        },
      ]
      image_paths = [ "IMAGE_VBMETAA_RAW=fuchsia.vbmeta" ]
    }
  }

  vbmeta("fuchsia_prime.vbmeta") {
    output_name = "fuchsia_prime"
    testonly = true
    if (custom_signing_script != "") {
      deps = [ ":fuchsia_prime_signed" ]
      zbi_outputs = get_target_outputs(":fuchsia_prime_signed")
      zbi = [ zbi_outputs[0] ]
    } else {
      deps = [ ":fuchsia_prime" ]
      zbi_outputs = get_target_outputs(":fuchsia_prime")
      zbi = [ zbi_outputs[0] ]
    }
    if (include_devmgr_config_in_vbmeta) {
      deps += [ ":devmgr_config_prime.txt" ]

      boot_args_file = get_target_outputs(":devmgr_config_prime.txt")

      # expecting a single file
      assert(
          [ boot_args_file[0] ] == boot_args_file,
          "expect a single output file form 'devmgr_config_prime.txt' target")

      prop_from_file = [
        {
          # zbi item type w/o ZBI_TYPE_ prefix
          type = "IMAGE_ARGS"
          file = boot_args_file[0]
        },
      ]
    }
  }

  default_image_deps += [ ":fuchsia.vbmeta" ]

  update_manifest += [
    {
      target = "fuchsia.vbmeta"
      sources = [ "$root_build_dir/fuchsia.vbmeta" ]
      deps = [ ":fuchsia.vbmeta" ]
    },
  ]
}

###
### Complete images for booting and installing the whole system.
###

# deps, inputs and args for the filesystem_sizes.json action.
filesystem_sizes_deps = []
filesystem_sizes_inputs = []
filesystem_sizes_args = []

data_image_path = "$target_out_dir/data.blk"

# data.blk creates minfs data partition. The partition is included in fvm.blk
# and fvm.sparse.blk. To increase the size of the data partition, increase
# the total size of the fvm images using |fvm_image_size|.
compiled_action("data.blk") {
  testonly = true

  rebased_data_image_path = rebase_path(data_image_path, root_build_dir)

  tool = "//zircon/tools/minfs"
  outputs = [ data_image_path ]
  depfile = data_image_path + ".d"
  args = [
    "--depfile",
    rebase_path(data_image_path, root_build_dir),
    "create",
  ]
  if (data_partition_manifest != "") {
    args += [
      "--manifest",
      rebase_path(data_partition_manifest),
    ]
  }

  metadata = {
    images = [
      {
        name = "data"
        path = rebased_data_image_path
        type = "blk"
      },
    ]
    image_paths = [ "IMAGE_DATA_RAW=$rebased_data_image_path" ]
  }
}

default_image_deps += [ ":data.blk" ]

# Record the maximum allowable FVM size in the build directory for later steps
# to check against.
max_fvm_size_file = "$root_build_dir/max_fvm_size.txt"
write_file(max_fvm_size_file, max_fvm_size)

fvm_blob_partition = {
  type = "blob"
  dep = ":blob.blk"

  # TODO(fxbug.dev/67015): Remove non-board/product variables
  if (blobfs_minimum_inodes != "") {
    minimum_inodes = blobfs_minimum_inodes
  } else if (blobfs_product_minimum_inodes != "") {
    minimum_inodes = blobfs_product_minimum_inodes
  } else if (blobfs_board_minimum_inodes != "") {
    minimum_inodes = blobfs_board_minimum_inodes
  }

  if (blobfs_minimum_data_bytes != "") {
    minimum_data_bytes = blobfs_minimum_data_bytes
  } else if (blobfs_product_minimum_data_bytes != "") {
    minimum_data_bytes = blobfs_product_minimum_data_bytes
  } else if (blobfs_board_minimum_data_bytes != "") {
    minimum_data_bytes = blobfs_board_minimum_data_bytes
  }

  if (blobfs_maximum_bytes != "") {
    maximum_bytes = blobfs_maximum_bytes
  } else if (blobfs_product_maximum_bytes != "") {
    maximum_bytes = blobfs_product_maximum_bytes
  } else if (blobfs_board_maximum_bytes != "") {
    maximum_bytes = blobfs_board_maximum_bytes
  }
}

# TODO(fxbug.dev/67015): Remove this and simply use fvm_blob_partition. Use
# product overrides where needed to have different dimensions specified.
fvm_blob_sparse_partition = {
  type = "blob"
  dep = ":blob.blk"

  # TODO(fxbug.dev/67015): Remove non-board/product variables
  if (blob_blobfs_minimum_inodes != "") {
    minimum_inodes = blobfs_minimum_inodes
  } else if (blobfs_product_minimum_inodes != "") {
    minimum_inodes = blobfs_product_minimum_inodes
  } else if (blobfs_board_minimum_inodes != "") {
    minimum_inodes = blobfs_board_minimum_inodes
  }

  if (blob_blobfs_minimum_data_bytes != "") {
    minimum_data_bytes = blobfs_minimum_data_bytes
  } else if (blobfs_product_minimum_data_bytes != "") {
    minimum_data_bytes = blobfs_product_minimum_data_bytes
  } else if (blobfs_board_minimum_data_bytes != "") {
    minimum_data_bytes = blobfs_board_minimum_data_bytes
  }

  if (blob_blobfs_maximum_bytes != "") {
    maximum_bytes = blobfs_maximum_bytes
  } else if (blobfs_product_maximum_bytes != "") {
    maximum_bytes = blobfs_product_maximum_bytes
  } else if (blobfs_board_maximum_bytes != "") {
    maximum_bytes = blobfs_board_maximum_bytes
  }
}

fvm_data_partition = {
  type = "data"
  dep = ":data.blk"

  # TODO(fxbug.dev/67015): Remove non-board/product variables
  if (minfs_minimum_inodes != "") {
    minimum_inodes = minfs_minimum_inodes
  } else if (minfs_product_minimum_inodes != "") {
    minimum_inodes = minfs_product_minimum_inodes
  } else if (minfs_board_minimum_inodes != "") {
    minimum_inodes = minfs_board_minimum_inodes
  }

  if (minfs_minimum_data_bytes != "") {
    minimum_data_bytes = minfs_minimum_data_bytes
  } else if (minfs_product_minimum_data_bytes != "") {
    minimum_data_bytes = minfs_product_minimum_data_bytes
  } else if (minfs_board_minimum_data_bytes != "") {
    minimum_data_bytes = minfs_board_minimum_data_bytes
  }

  if (minfs_maximum_bytes != "") {
    maximum_bytes = minfs_maximum_bytes
  } else if (minfs_product_maximum_bytes != "") {
    maximum_bytes = minfs_product_maximum_bytes
  } else if (minfs_board_maximum_bytes != "") {
    maximum_bytes = minfs_board_maximum_bytes
  }
}

# The rule for generating raw fvm.blk. Normally, fastboot fvm images should be
# used in place of the raw images. But it is needed when the build is not configured
# to generate the fastboot image, or when users run "fx netboot", which needs to
# build the netboot.zbi target that depends on fvm.blk
fvm_raw_path = "$target_out_dir/fvm.blk"
generate_fvm("fvm.blk") {
  testonly = true

  output_name = fvm_raw_path
  rebased_output_name = rebase_path(output_name, root_build_dir)

  args = fvm_create_args
  if (fvm_image_size != "") {
    args += [
      "--length",
      "${fvm_image_size}",
    ]
  }
  partitions = [
    fvm_blob_partition,
    fvm_data_partition,
  ]
  metadata = {
    images = [
      {
        archive = add_qemu_to_build_archives
        name = "storage-full"
        path = rebased_output_name
        type = "blk"
      },
    ]
    image_paths = [ "IMAGE_FVM_RAW=$rebased_output_name" ]
  }
}

fvm_sparse_blk_path = "$target_out_dir/fvm.sparse.blk"

# fvm.sparse.blk creates a sparse FVM partition image containing the blob
# partition produced by blob.blk and the data partition produced by data.blk.
# fvm.sparse.blk is primarily invoked and used by the paver boot, via `fx
# pave`.
generate_fvm("fvm.sparse.blk") {
  testonly = true

  output_name = fvm_sparse_blk_path
  rebased_output_name = rebase_path(output_name, root_build_dir)

  deps = [
    ":blob.blk",
    ":data.blk",
  ]
  args = fvm_sparse_args
  partitions = [
    fvm_blob_partition,
    fvm_data_partition,
  ]

  metadata = {
    images = [
      {
        archive = true
        bootserver_pave = [ "--fvm" ]
        name = "storage-sparse"
        path = rebased_output_name
        type = "blk"
      },
    ]
    image_paths = [ "IMAGE_FVM_SPARSE=$rebased_output_name" ]
  }
}
default_image_deps += [ ":fvm.sparse.blk" ]

filesystem_sizes_deps += [
  ":blob.blk",
  ":data.blk",
  ":fvm.sparse.blk",
  "//src/storage/bin/fvm($host_toolchain)",
  "//zircon/tools/blobfs($host_toolchain)",
  "//zircon/tools/minfs($host_toolchain)",
]
filesystem_sizes_inputs += [
  blob_image_path,
  data_image_path,
  fvm_sparse_blk_path,
]
filesystem_sizes_args += [
  "--fvm-blk",
  rebase_path(fvm_sparse_blk_path),
  "--blob-blk",
  rebase_path(blob_image_path),
  "--data-blk",
  rebase_path(data_image_path),
  "--fvm-tool",
  rebase_path("$zircon_tools_dir/fvm"),
  "--blobfs-tool",
  rebase_path("$zircon_tools_dir/blobfs"),
  "--minfs-tool",
  rebase_path("$zircon_tools_dir/minfs"),
  "--max-fvm-contents-size",
  max_fvm_size,
  "--max-blob-contents-size",
  max_blob_contents_size,
  "--max-blob-image-size",
  max_blob_image_size,
  "--max-data-contents-size",
  max_data_contents_size,
  "--max-data-image-size",
  max_data_image_size,
]

# fvm.blob.sparse.blk creates a sparse FVM partition image containing the blob
# partition produced by blob.blk and an empty data partition that will be
# formatted on first boot.
fvm_blob_sparse_blk_path = "$target_out_dir/fvm.blob.sparse.blk"
rebased_fvm_blob_sparse_blk_path =
    rebase_path(fvm_blob_sparse_blk_path, root_build_dir)
generate_fvm("fvm.blob.sparse.blk") {
  testonly = true
  output_name = fvm_blob_sparse_blk_path
  deps = [ ":blob.blk" ]
  args = fvm_sparse_args
  with_empty_minfs = true
  partitions = [ fvm_blob_sparse_partition ]

  metadata = {
    image_paths = [ "IMAGE_FVM_BLOB_SPARSE=$rebased_fvm_blob_sparse_blk_path" ]

    if (include_fvm_blob_sparse) {
      images = [
        {
          # Hack: Infra expects bootserver_pave to be present
          # in the GN graph for this image to be built.
          bootserver_pave = []
          name = "fvm.blob.sparse"
          path = rebased_fvm_blob_sparse_blk_path
          type = "blk"
        },
      ]
    }
  }
}
default_image_deps += [ ":fvm.blob.sparse.blk" ]

if (fvm_partition != "") {
  # If |fvm_partition| is specified, generate a fastboot fvm format suitable for
  # fastboot flashing. The image will be used for emu/qemu as well.
  fvm_generation_args = []
  fvm_partitions = []
  fvm_deps = []
  if (fvm_emmc_partition_size != "") {
    # If "fvm_emmc_partition_size" is specified, generate for emmc devices.
    fvm_generation_args = fvm_create_args
    fvm_generation_args += [
      "--compress",
      "lz4",
      "--length",
      fvm_emmc_partition_size,
      "--resize-image-file-to-fit",
    ]
    fvm_partitions = [
      fvm_blob_partition,
      fvm_data_partition,
    ]
  } else if (fvm_ftl_nand_page_size != "") {
    # For raw NAND devices that support flashing via fastboot, generate the NAND
    # FVM image as well which contains the necessary OOB bytes to initialize the
    # FTL.
    assert(fvm_ftl_nand_oob_size != "",
           "fvm_ftl_nand_oob_size must be specified")
    assert(fvm_ftl_nand_pages_per_block != "",
           "fvm_ftl_nand_pages_per_block must be specified")
    assert(fvm_ftl_nand_block_count != "",
           "fvm_ftl_nand_block_count must be specified")
    fvm_generation_args = [
      "ftl-raw-nand",
      "--nand-page-size",
      fvm_ftl_nand_page_size,
      "--nand-oob-size",
      fvm_ftl_nand_oob_size,
      "--nand-pages-per-block",
      fvm_ftl_nand_pages_per_block,
      "--nand-block-count",
      fvm_ftl_nand_block_count,
      "--max-disk-size",
      max_fvm_size,

      # Make sure to use fvm.blob.sparse.blk, which has an empty minfs
      # partition. This triggers the device to re-generate minfs at runtime
      # using the proper encryption keys.
      "--sparse",
      rebase_path(fvm_blob_sparse_blk_path),
    ]
    fvm_deps = [ ":fvm.blob.sparse.blk" ]
  } else {
    assert(
        false,
        "|fvm_partition| is specified. But failed to determine the target format.")
  }

  generate_fvm("fvm.fastboot.blk") {
    testonly = true

    output_name = "$target_out_dir/fvm.fastboot.blk"
    rebased_output_name = rebase_path(output_name, root_build_dir)

    args = fvm_generation_args
    partitions = fvm_partitions
    metadata = {
      images = [
        {
          archive = true
          name = "fvm.fastboot"
          path = rebased_output_name
          type = "blk"
          fastboot_flash = [ fvm_partition ]
        },
      ]
      image_paths = [ "IMAGE_FVM_FASTBOOT=$rebased_output_name" ]
    }
    deps = fvm_deps
  }
  default_image_deps += [ ":fvm.fastboot.blk" ]
} else {
  default_image_deps += [ ":fvm.blk" ]
}

zbi_input("fvm.blk_ramdisk") {
  testonly = true

  type = "ramdisk"

  # Use data_deps and not deps so that the contents of the fvm don't get
  # included in the dependent zbi.
  data_deps = [ ":fvm.blk" ]

  sources = [ "$target_out_dir/fvm.blk" ]
}

# This rolls the primary ZBI together with a compressed RAMDISK image of
# fvm.blk into a fat ZBI that boots the full system without using any real
# storage.  The system decompresses the fvm.blk image into memory and then
# sees that RAM disk just as if it were a real disk on the device.
zbi("netboot") {
  testonly = true

  output_dir = root_out_dir

  deps = [
    ":fuchsia",
    ":fvm.blk_ramdisk",
  ]

  metadata = {
    images = [
      {
        archive = enable_netboot
        bootserver_netboot = [ "--boot" ]
        name = "netboot"
        path = "netboot.zbi"
        type = "zbi"
      },
    ]
    image_paths = [
      "IMAGE_NETBOOT_ZBI=netboot.zbi",

      # TODO(mcgrathr): The complete ZBI can be used with a separate kernel
      # too, the kernel image in it will just be ignored.  So just use the
      # primary ZBI for this until all uses are converted to using the ZBI
      # alone.  Then remove this as IMAGE_BOOT_RAM variable should no
      # longer be in use.
      "IMAGE_NETBOOT_RAM=netboot.zbi",
    ]
  }
}

if (target_cpu != "arm64" && !use_vboot) {
  # TODO(surajmalhotra): Remove this target once SDK no longer depends on it.
  vboot("vboot") {
    testonly = true
    output_name = "fuchsia"
    deps = [ ":fuchsia" ]

    metadata = {
      images = [
        {
          name = "zircon-vboot"
          path = "fuchsia.vboot"
          type = "vboot"
        },
      ]
    }
  }
  default_image_deps += [ ":vboot" ]

  # EFI ESP images.
  esp("esp") {
    output_name = "fuchsia"
    testonly = true
    if (always_zedboot) {
      cmdline = "zedboot/efi_cmdline.txt"
    } else {
      cmdline = "efi_local_cmdline.txt"
    }
    metadata = {
      images = [
        {
          archive = true
          bootserver_pave = [ "--bootloader" ]
          bootserver_pave_zedboot = [ "--bootloader" ]
          name = "efi"
          path = "fuchsia.esp.blk"
          type = "blk"
        },
      ]
      image_paths = [ "IMAGE_ESP_RAW=fuchsia.esp.blk" ]
    }
  }
  default_image_deps += [ ":esp" ]

  if (!use_vboot && custom_signing_script == "") {
    update_manifest += [
      {
        deps = [ ":esp" ]
        target = "bootloader"
      },
    ]
  }
}

# Track some firmware information locally so we can flash it without
# re-calculating all the names and paths.
firmware_info = []

foreach(firmware, firmware_prebuilts) {
  if (firmware.type == "") {
    # Don't add a trailing delimiter if firmware.type is empty.
    name = "firmware"
    bootserver_arg = "--firmware"
  } else {
    name = "firmware_${firmware.type}"
    bootserver_arg = "--firmware-${firmware.type}"
  }

  # By convention image_paths shell variables are upper-case. There must
  # be a better way to do this but I'm not sure what it is.
  upper_name = name
  upper_name = string_replace(upper_name, "a", "A")
  upper_name = string_replace(upper_name, "b", "B")
  upper_name = string_replace(upper_name, "c", "C")
  upper_name = string_replace(upper_name, "d", "D")
  upper_name = string_replace(upper_name, "e", "E")
  upper_name = string_replace(upper_name, "f", "F")
  upper_name = string_replace(upper_name, "g", "G")
  upper_name = string_replace(upper_name, "h", "H")
  upper_name = string_replace(upper_name, "i", "I")
  upper_name = string_replace(upper_name, "j", "J")
  upper_name = string_replace(upper_name, "k", "K")
  upper_name = string_replace(upper_name, "l", "L")
  upper_name = string_replace(upper_name, "m", "M")
  upper_name = string_replace(upper_name, "n", "N")
  upper_name = string_replace(upper_name, "o", "O")
  upper_name = string_replace(upper_name, "p", "P")
  upper_name = string_replace(upper_name, "q", "Q")
  upper_name = string_replace(upper_name, "r", "R")
  upper_name = string_replace(upper_name, "s", "S")
  upper_name = string_replace(upper_name, "t", "T")
  upper_name = string_replace(upper_name, "u", "U")
  upper_name = string_replace(upper_name, "v", "V")
  upper_name = string_replace(upper_name, "w", "W")
  upper_name = string_replace(upper_name, "x", "X")
  upper_name = string_replace(upper_name, "y", "Y")
  upper_name = string_replace(upper_name, "z", "Z")

  copy(name) {
    testonly = true
    sources = [ rebase_path("${firmware.path}${firmware_prebuilts_path_suffix}",
                            root_build_dir) ]
    outputs = [ "$root_out_dir/$name.img" ]

    metadata = {
      images = [
        {
          archive = true
          bootserver_pave = [ bootserver_arg ]
          bootserver_pave_zedboot = [ bootserver_arg ]
          name = name
          path = "$name.img"
          type = "img"

          if (defined(firmware.partition)) {
            fastboot_flash = [ firmware.partition ]
          }
        },
      ]
      image_paths = [ "IMAGE_${upper_name}=$name.img" ]
    }
  }

  default_image_deps += [ ":$name" ]

  update_manifest += [
    {
      target = name
      deps = [ ":$name" ]
      sources = [ "$root_out_dir/$name.img" ]
    },
  ]

  if (defined(firmware.partition)) {
    firmware_info += [
      {
        name = name
        partition = firmware.partition

        # Both the output dir and the build archive put the image at this path.
        out_path = "$name.img"
      },
    ]
  }
}

# If a GPT image was specified, make it available as a build artifact.
if (gpt_image != "") {
  copy("gpt") {
    testonly = true
    sources = [ rebase_path(gpt_image, root_build_dir) ]
    outputs = [ "$root_out_dir/gpt.bin" ]

    metadata = {
      images = [
        {
          archive = true
          name = "gpt"
          path = "gpt.bin"
          type = "bin"
        },
      ]
      image_paths = [ "IMAGE_GPT=gpt.bin" ]
    }
  }

  default_image_deps += [ ":gpt" ]
}

# Copy any board-specific tools.
group("board_tools") {
  deps = []

  foreach(tool_path, board_tools) {
    basename = get_path_info(tool_path, "file")
    copy("board_tool_$basename") {
      sources = [ rebase_path(tool_path, root_build_dir) ]
      outputs = [ "$root_out_dir/board_tools/$basename" ]

      metadata = {
        images = [
          {
            archive = true
            name = "$basename"
            path = "board_tools/$basename"
            type = "script"
          },
        ]
      }
    }

    deps += [ ":board_tool_$basename" ]
  }
}

default_image_deps += [ ":board_tools" ]

action("filesystem_sizes.json") {
  testonly = true
  hermetic_deps = false
  script = "format_filesystem_sizes.py"
  deps = filesystem_sizes_deps + [ ":fuchsia" ]
  if (recovery_is_zedboot) {
    deps += [ "zedboot:zbi" ]
  }
  output_name = "$root_build_dir/filesystem_sizes.json"
  outputs = [ output_name ]
  fuchsia_target_outputs = get_target_outputs(":fuchsia")

  inputs = filesystem_sizes_inputs + fuchsia_target_outputs
  if (recovery_is_zedboot) {
    # Can't use get_target_outputs() because this defined in another file.
    inputs += [ "$root_out_dir/zedboot.zbi" ]
  }

  args = filesystem_sizes_args + [
           "--fuchsia-zbi",
           rebase_path(fuchsia_target_outputs[0]),
           "--max-fuchsia-zbi-size",
           max_fuchsia_zbi_size,
           "--output",
           rebase_path(output_name),
         ]
  if (recovery_is_zedboot) {
    args += [
      "--zedboot-zbi",
      rebase_path("$root_out_dir/zedboot.zbi"),
      "--max-zedboot-zbi-size",
      max_zedboot_zbi_size,
    ]
  }
}

# Pseudo-target to record information about the sizes of filesystems assembled
# during the build for later analysis.
group("record_filesystem_sizes") {
  testonly = true
  deps = [
    ":elf_sizes.json",
    ":filesystem_sizes.json",
  ]
}

###
### Paver and flash scripts, and archives using those images and zedboot's images.
###

action("flash_script") {
  # Required for dependency on testonly firmware image targets.
  testonly = true

  script = "//build/images/generate_flash_script.sh"
  outputs = [ "$root_out_dir/flash.sh" ]

  if (custom_signing_script != "") {
    image_suffix = "zbi.signed"
  } else {
    image_suffix = "zbi"
  }
  image = "$root_out_dir/fuchsia.${image_suffix}"
  vbmeta = "$root_out_dir/fuchsia.vbmeta"

  if (recovery_is_zedboot) {
    recovery_image = "$root_out_dir/zedboot.${image_suffix}"
    recovery_vbmeta = "$root_out_dir/zedboot.vbmeta"
  } else {
    recovery_image = "$root_out_dir/recovery.zbi"
    recovery_vbmeta = "$root_out_dir/recovery.vbmeta"
  }

  # A list of partitions for the flash json manifest that will be
  # generated.  The first item should be the partition name and the
  # second should be the path to the image for the partition.
  parts = [
    [
      zircon_a_partition,
      rebase_path(image),
    ],
    [
      zircon_b_partition,
      rebase_path(image),
    ],
    [
      zircon_r_partition,
      rebase_path(recovery_image),
    ],
    [
      vbmeta_a_partition,
      rebase_path(vbmeta),
    ],
    [
      vbmeta_b_partition,
      rebase_path(vbmeta),
    ],
    [
      vbmeta_r_partition,
      rebase_path(recovery_vbmeta),
    ],
  ]

  recovery_parts = [
    [
      zircon_a_partition,
      rebase_path(recovery_image),
    ],
    [
      zircon_b_partition,
      rebase_path(recovery_image),
    ],
    [
      zircon_r_partition,
      rebase_path(recovery_image),
    ],
    [
      vbmeta_a_partition,
      rebase_path(recovery_vbmeta),
    ],
    [
      vbmeta_b_partition,
      rebase_path(recovery_vbmeta),
    ],
    [
      vbmeta_r_partition,
      rebase_path(recovery_vbmeta),
    ],
  ]

  host_out_dir = get_label_info(":bogus($host_toolchain)", "root_out_dir")
  args = [
    "--image=" + rebase_path(image, root_build_dir),
    "--recovery-image=" + rebase_path(recovery_image, root_build_dir),
    "--output=" + rebase_path(outputs[0], root_build_dir),
    "--zircon-a=${zircon_a_partition}",
    "--zircon-b=${zircon_b_partition}",
    "--zircon-r=${zircon_r_partition}",
    "--vbmeta-a=${vbmeta_a_partition}",
    "--vbmeta-b=${vbmeta_b_partition}",
    "--vbmeta-r=${vbmeta_r_partition}",
    "--active=${active_partition}",
    "--product=${fastboot_product}",
    "--pre-erase-flash=${pre_erase_flash}",
    "--fastboot-path=" + rebase_path("$host_out_dir/fastboot", root_build_dir),
  ]
  if (custom_signing_script != "") {
    args += [ "--signed=true" ]
  }
  deps = [ ":fastboot" ]

  # A list of partitions for the flash json manifest that will be
  # generated.  The first item should be the partition name and the
  # second should be the path to the image for the partition. These
  # are the images flashed for the firmware/bootloader.
  bootloader_parts = []

  foreach(info, firmware_info) {
    args += [ "--firmware=${info.partition}:${info.out_path}" ]
    deps += [ ":${info.name}" ]
    bootloader_parts += [ [
          info.partition,
          rebase_path("$root_out_dir/${info.out_path}"),
        ] ]
  }

  if (fvm_partition != "") {
    image_path = get_target_outputs(":fvm.fastboot.blk")
    args += [
      "--fvm-image=" + rebase_path(image_path[0], root_build_dir),
      "--fvm=${fvm_partition}",
    ]
    deps += [ ":fvm.fastboot.blk" ]
    parts += [ [
          fvm_partition,
          rebase_path(image_path[0]),
        ] ]
  }

  metadata = {
    images = [
      {
        name = "flash-script"
        path = "flash.sh"
        type = "script"
      },
    ]
    image_paths = [ "IMAGE_FLASH_SH=netboot.sh" ]
    flash_manifest = [
      {
        version = 1
        manifest = [
          {
            name = "recovery"
            bootloader_partitions = bootloader_parts
            partitions = recovery_parts
            oem_files = []
          },
          {
            name = "fuchsia"
            bootloader_partitions = bootloader_parts
            partitions = parts
            oem_files = []
          },
        ]
      },
    ]
  }
}

fastboot_manifest_file = "$root_build_dir/flash.json"
generated_file("fastboot_manifest") {
  testonly = true
  outputs = [ fastboot_manifest_file ]
  output_conversion = "json"
  data_keys = [ "flash_manifest" ]
  deps = [ ":flash_script" ]
}

default_image_deps += [ recovery_label ]

action("flash_script_archive") {
  script = "//build/images/generate_flash_script.sh"
  outputs = [ "$root_out_dir/flash-archive.sh" ]

  if (custom_signing_script != "") {
    image_suffix = "signed.zbi.signed"
  } else {
    image_suffix = "zbi"
  }
  image = "zircon-a.${image_suffix}"

  if (recovery_is_zedboot) {
    recovery_image = "zircon-r.${image_suffix}"
  } else {
    # Archived recovery image alway uses .zbi suffix whether signed or not.
    recovery_image = "zircon-r.zbi"
  }

  args = [
    "--image=${image}",
    "--recovery-image=${recovery_image}",
    "--output=" + rebase_path(outputs[0], root_build_dir),
    "--zircon-a=${zircon_a_partition}",
    "--zircon-b=${zircon_b_partition}",
    "--zircon-r=${zircon_r_partition}",
    "--vbmeta-a=${vbmeta_a_partition}",
    "--vbmeta-b=${vbmeta_b_partition}",
    "--vbmeta-r=${vbmeta_r_partition}",
    "--active=${active_partition}",
    "--product=${fastboot_product}",
    "--pre-erase-flash=${pre_erase_flash}",
    "--fastboot-path=fastboot.exe.$host_platform",
  ]

  foreach(info, firmware_info) {
    args += [ "--firmware=${info.partition}:${info.out_path}" ]
  }

  if (fvm_partition != "") {
    image_path = get_target_outputs(":fvm.fastboot.blk")
    args += [
      "--fvm-image=" + get_path_info(image_path[0], "file"),
      "--fvm=${fvm_partition}",
    ]
  }

  metadata = {
    images = [
      {
        archive = true
        name = "flash"
        type = "sh"
        path = "flash-archive.sh"
      },
    ]
  }
}

paver_targets = [
  {
    name = "netboot-script"
    outputs = [ "$root_build_dir/netboot.sh" ]
    switch = "--netboot="
    extra_bootserver_arguments = ""

    deps = [ ":bootserver" ]

    # XXX(46415): The build graph for "bringup" (bootfs_only) MUST only
    # contain one zircon-a metadata target, which means that anything
    # reaching fuchsia.zbi must be excluded from the build graph.
    if (bootfs_only) {
      deps += [ "bringup" ]
      if (use_vbmeta) {
        deps += [ "//build/images/bringup:bringup.vbmeta" ]
      }
    } else {
      deps += [ ":netboot" ]
    }
    metadata = {
      images = [
        {
          name = name
          path = "netboot.sh"
          type = "script"
        },
      ]
      image_paths = [ "IMAGE_NETBOOT_SH=netboot.sh" ]
    }
  },
  {
    name = "paver-script"
    outputs = [ "$root_build_dir/pave.sh" ]
    deps = [ ":bootserver" ]
    if (bootfs_only) {
      deps += [ "bringup" ]
      if (use_vbmeta) {
        deps += [ "//build/images/bringup:bringup.vbmeta" ]
      }
      switch = "--netboot="
    } else {
      deps += default_image_deps
      switch = "--pave="
    }
    extra_bootserver_arguments = ""
    metadata = {
      images = [
        {
          name = name
          path = "pave.sh"
          type = "script"
        },
      ]
      image_paths = [ "IMAGE_PAVE_SH=pave.sh" ]
    }
  },
]

if (recovery_is_zedboot) {
  paver_targets += [
    {
      name = "zedboot-script"
      outputs = [ "$root_build_dir/pave-zedboot.sh" ]
      deps = [ ":bootserver" ]
      if (bootfs_only) {
        deps += [ "bringup" ]
        if (use_vbmeta) {
          deps += [ "//build/images/bringup:bringup.vbmeta" ]
        }
        switch = "--netboot="
      } else {
        deps += [ "zedboot" ]
        switch = "--pave_zedboot="
      }
      extra_bootserver_arguments = "--allow-zedboot-version-mismatch"
      metadata = {
        images = [
          {
            name = name
            path = "pave-zedboot.sh"
            type = "script"
          },
        ]
        image_paths = [ "IMAGE_PAVE_ZEDBOOT_SH=pave-zedboot.sh" ]
      }
    },
  ]
}

# Name the entrypoint scripts in images.json as well, as that they are
# presently the stable API to perform a pave/netboot/etc. without botanist.

archive_formats = [
  "tar",
  "tgz",
]

generated_file("archive-images-manifest") {
  testonly = true
  outputs = [ "$root_build_dir/archive-images-manifest.json" ]
  output_conversion = "json"
  data_keys = [ "images" ]
  deps = [
    ":archive-extras",
    ":bootserver",
    ":images",
  ]
}
foreach(format, archive_formats) {
  paver_targets += [
    {
      name = "archive-$format"
      outputs = [ "$root_build_dir/build-archive.$format" ]
      switch = "--archive="
      extra_bootserver_arguments = ""
      deps = [
        ":archive-extras",
        ":flash_script_archive",
        ":paver-script",
      ]
      metadata = {
        archives = [
          {
            name = "archive"
            path = "build-archive.$format"
            type = "$format"
          },
        ]
      }
    },
  ]
}

archive_deps = []
uefi_disk_deps = []
foreach(target, paver_targets) {
  action(target.name) {
    deps = []
    if (defined(target.deps)) {
      deps += target.deps
    }
    testonly = true
    outputs = target.outputs
    depfile = "${outputs[0]}.d"
    hermetic_deps = false
    script = "pack-images.py"
    args = [
      "--depfile=" + rebase_path(depfile, root_build_dir),
      target.switch + rebase_path(outputs[0], root_build_dir),
      "--board_name=${board_name}",
    ]

    if (additional_bootserver_arguments != "") {
      args += [
        "--additional_bootserver_arguments=${additional_bootserver_arguments}",
      ]
    }
    if (target.extra_bootserver_arguments != "") {
      args += [ "--additional_bootserver_arguments=${target.extra_bootserver_arguments}" ]
    }

    args += [
      "archive-images-manifest.json",
      "checkout_artifacts.json",
    ]

    if (defined(target.metadata)) {
      metadata = target.metadata
    }
  }
  archive_deps += [ ":${target.name}" ]
  uefi_disk_deps += [ ":${target.name}" ]
}

group("archives") {
  testonly = true
  deps = archive_deps
}

###
### Amber updates.
###

# update_packages.manifest contains the same entries as the pkgsvr_index but
# additionally includes the system_image package.

update_meta_far_merkle_index = "$target_out_dir/update_meta_far_merkle_index"
generate_package_metadata("update_meta_far_merkle_index") {
  testonly = true
  outputs = [ update_meta_far_merkle_index ]
  data_keys = [ "meta_far_merkle_index_entries" ]
  deps = [
    ":base_packages",
    ":cache_packages",
    ":meta_packages",
    ":system_image.meta",
  ]
}

recovery_images_list = root_build_dir + "/recovery_images_list"
generated_file("recovery_images_list") {
  testonly = true
  outputs = [ recovery_images_list ]
  output_conversion = "list lines"
  data_keys = [ "update_target" ]
  deps = [ recovery_label ]
}

action("update_packages.manifest") {
  visibility = [ ":update.manifest" ]
  testonly = true

  outputs = [ "$target_out_dir/$target_name" ]
  deps = [ ":update_meta_far_merkle_index" ]
  inputs = [ update_meta_far_merkle_index ]
  hermetic_deps = false
  script = "manifest_content_expand.sh"
  args = [
    rebase_path(update_meta_far_merkle_index, root_build_dir),
    rebase_path(outputs[0], root_build_dir),
  ]
}

action("update_packages.manifest.json") {
  visibility = [ ":update.manifest" ]
  testonly = true

  outputs = [ "$target_out_dir/$target_name" ]
  deps = [ ":update_meta_far_merkle_index" ]
  inputs = [ update_meta_far_merkle_index ]

  hermetic_deps = false
  script = "generate_packages_json.py"
  args = [
    rebase_path(update_meta_far_merkle_index, root_build_dir),
    rebase_path(outputs[0], root_build_dir),
  ]
}

# The update package manifest contains the pkgsvr_index and the target
# system kernel images.
action("update.manifest") {
  visibility = [ ":*" ]
  testonly = true

  additional_update_manifest_entries = [
    {
      target = "packages"
      deps = [ ":update_packages.manifest" ]
    },
    {
      target = "packages.json"
      deps = [ ":update_packages.manifest.json" ]
    },

    # Add the meta/package JSON file that makes this the "update" package.
    {
      target = "meta/package"
      sources = [ "update_package.json" ]
    },
    {
      target = "version"
      sources = [ rebase_path(build_info_files.version, "", root_build_dir) ]
    },
    {
      target = "board"
      sources = [ board_name_file ]
    },
  ]
  hermetic_deps = false
  script = "manifest.py"

  outputs = [ "$target_out_dir/$target_name" ]
  args = [ "--output=" + rebase_path(outputs[0], root_build_dir) ]

  recovery_images_list_outputs = get_target_outputs(":recovery_images_list")
  sources = recovery_images_list_outputs

  deps = [
    ":recovery_images_list",

    # This dep ensures the version file included below is always generated,
    # which is presently significant only really for bringup, as bringup still
    # attempts to build this target.
    "//build/info:build-info",
  ]

  # Use metadata from recovery labels to create manifest targets
  args += [
    "--manifest",
    rebase_path(recovery_images_list_outputs[0], root_build_dir),
  ]

  # Each entry optionally specifies deps or sources that are added to that of
  # this action, as well as a `target` to be included in the generated
  # manifest.
  foreach(entry, update_manifest + additional_update_manifest_entries) {
    entry_source = ""
    if (defined(entry.deps)) {
      deps += entry.deps
    }

    if (defined(entry.sources)) {
      # TODO(fxbug.dev/3157): We should only have single source
      sources = []
      sources += entry.sources
      entry_source = sources[0]
    } else if (defined(entry.deps)) {
      foreach(label, entry.deps) {
        # TODO(fxbug.dev/3157): We should only have single output
        dep_outputs = []
        dep_outputs += get_target_outputs(label)
        entry_source = dep_outputs[0]
      }
    }
    entry_source = rebase_path(entry_source, root_build_dir)
    args += [ "--entry=${entry.target}=${entry_source}" ]
  }
}

pm_build("update.meta") {
  visibility = [ ":*" ]
  testonly = true
  manifest = ":update.manifest"
  package_name = "update"
}

###
### Generate an update package with system_image_prime and fuchsia_prime.
###

# The prime images are used to have an alternate known-compatible OTA
# target for integration testing.

update_prime_meta_far_merkle_index =
    "$target_out_dir/update_prime_meta_far_merkle_index"
generate_package_metadata("update_prime_meta_far_merkle_index") {
  testonly = true
  outputs = [ update_prime_meta_far_merkle_index ]
  data_keys = [ "meta_far_merkle_index_entries" ]
  deps = [
    ":base_packages",
    ":meta_packages",
    ":system_image_prime.meta",
  ]
}

action("update_prime_packages.manifest") {
  visibility = [ ":update_prime.manifest" ]
  testonly = true

  outputs = [ "$target_out_dir/$target_name" ]
  deps = [ ":update_prime_meta_far_merkle_index" ]
  inputs = [ update_prime_meta_far_merkle_index ]
  hermetic_deps = false
  script = "manifest_content_expand.sh"
  args = [
    rebase_path(update_prime_meta_far_merkle_index, root_build_dir),
    rebase_path(outputs[0], root_build_dir),
  ]
}

action("update_prime_packages.manifest.json") {
  visibility = [ ":update_prime.manifest" ]
  testonly = true

  outputs = [ "$target_out_dir/$target_name" ]
  deps = [ ":update_prime_meta_far_merkle_index" ]
  inputs = [ update_prime_meta_far_merkle_index ]

  hermetic_deps = false
  script = "generate_packages_json.py"
  args = [
    rebase_path(update_prime_meta_far_merkle_index, root_build_dir),
    rebase_path(outputs[0], root_build_dir),
  ]
}

action("update_prime.manifest") {
  visibility = [ ":*" ]
  testonly = true
  hermetic_deps = false
  script = "manifest.py"

  outputs = [ "$target_out_dir/$target_name" ]

  args = [ "--output=" + rebase_path(outputs[0], root_build_dir) ]

  deps = [
    ":update.manifest",
    ":update_prime_packages.manifest",
    ":update_prime_packages.manifest.json",
    zbi_prime.dep,
  ]
  update_manifest_outputs = get_target_outputs(":update.manifest")
  update_prime_packages_manifest_outputs =
      get_target_outputs(":update_prime_packages.manifest")
  update_prime_packages_manifest_json_outputs =
      get_target_outputs(":update_prime_packages.manifest.json")
  zbi_outputs = get_target_outputs(zbi_prime.dep)

  sources = update_manifest_outputs
  args += [
    "--rewrite",
    "meta/package={target}=" +
        rebase_path("update_package.json", root_build_dir),
    "--rewrite",
    "packages={target}=" +
        rebase_path(update_prime_packages_manifest_outputs[0], root_build_dir),
    "--rewrite",
    "packages.json={target}=" +
        rebase_path(update_prime_packages_manifest_json_outputs[0],
                    root_build_dir),
    "--rewrite",
    zbi_prime.updater + "={target}=" +
        rebase_path(zbi_outputs[0], root_build_dir),
  ]

  if (use_vbmeta) {
    deps += [ ":fuchsia_prime.vbmeta" ]
    fuchsia_prime_vbmeta = get_target_outputs(":fuchsia_prime.vbmeta")
    args += [
      "--rewrite",
      "fuchsia.vbmeta={target}=" +
          rebase_path(fuchsia_prime_vbmeta[0], root_build_dir),
    ]
  }

  args += [
    "--manifest",
    rebase_path(update_manifest_outputs[0], root_build_dir),
  ]
}

pm_build("update_prime.meta") {
  visibility = [ ":*" ]
  testonly = true
  manifest = ":update_prime.manifest"
  package_name = "update_prime"
}

# This output is a manifest of manifests that is usable as an input to `pm
# publish -lp`, a tool for publishing a set of packages from a build produced
# list of package manifests.
all_package_manifests_list = root_build_dir + "/all_package_manifests.list"
generate_package_metadata("all_package_manifests.list") {
  testonly = true
  outputs = [ all_package_manifests_list ]
  data_keys = [ "package_output_manifests" ]
  rebase = root_build_dir
  deps = [
    ":packages",
    ":system_image.meta",
    ":system_image_prime.meta",
    ":update.meta",
    ":update_prime.meta",
  ]
}

# A component ID index maps component instance IDs to component monikers.
# Indices are defined using the component_id_index() GN template. They are
# merged together into a single index and supplied to appmgr using the
# component_id_index_config() template, which produces a config_data().
#
# If a system assembly contains components which use isolated storage, then it
# needs include a component_id_index_config().
#
# For more details, see //docs/development/components/component_id_index.md#system-assembly
component_id_index_config("component_id_index_config") {
  testonly = fuchsia_zbi_testonly

  # crawl for component_id_index()s in the base set.
  deps = [ ":base_packages" ]
}

component_index_metadata = "$target_out_dir/component_index_metadata"
generate_component_index("component_index_metadata") {
  visibility = [
    "//build/images:*",
    "//src/sys/component_index:*",
  ]
  testonly = fuchsia_zbi_testonly

  outputs = [ component_index_metadata ]

  deps = [ ":universe_packages" ]

  metadata = {
    # Don't collect all expect_includes() in the universe
    expect_includes_barrier = []
  }
}

# We copy the metatdata to the root dir so that it can easily be used by host
# tools
copy("root_component_index_metadata") {
  testonly = true
  sources = [ component_index_metadata ]
  outputs = [ "$root_out_dir/component_index_metadata" ]
  deps = [ ":component_index_metadata" ]
}

# The system index is the index of all universe packages, naming each
# blobs.json file instead of its merkleroot, and including a tag of the package
# set the package is a part of (base/cache/universe). Additionally the
# system_index has the system package itself, and the system update package.
system_index = "$target_out_dir/system_index"

tagged_snapshot_manifests = [
  {
    tag = "monolith"
    deps = [
      ":base_packages",
      ":meta_packages",
      ":system_image.meta",
      ":update.meta",
    ]
  },
  {
    tag = "preinstall"
    deps = [ ":cache_packages" ]
  },
  {
    tag = "available"
    deps = [ ":universe_packages" ]
  },
]

all_snapshot_entries = []
foreach(manifest, tagged_snapshot_manifests) {
  untagged_entries = "${manifest.tag}.snapshot_entries.untagged"
  generate_package_metadata(untagged_entries) {
    testonly = true
    outputs = [ target_gen_dir + "/" + target_name ]
    deps = manifest.deps
    data_keys = [ "snapshot_entries" ]
  }

  tagged_entries = "${manifest.tag}.snapshot_entries"
  action(tagged_entries) {
    testonly = true
    deps = [ ":" + untagged_entries ]
    script = "add_tag_to_manifest.sh"
    inputs = [ target_gen_dir + "/" + untagged_entries ]
    outputs = [ root_build_dir + "/" + target_name ]
    args = [
      manifest.tag,
      rebase_path(inputs[0], root_build_dir),
      rebase_path(outputs[0], root_build_dir),
    ]
  }
  all_snapshot_entries += [ tagged_entries ]
}

action("system_index") {
  visibility = [ ":system_snapshot" ]
  testonly = true

  hermetic_deps = false
  script = "//build/cat.sh"
  outputs = [ "$target_out_dir/$target_name" ]
  args = [ rebase_path(outputs[0], root_build_dir) ]
  deps = []
  foreach(entry, all_snapshot_entries) {
    args += [ entry ]
    deps += [ ":" + entry ]
  }
}

compiled_action("system_snapshot") {
  tool = "//src/sys/pkg/bin/pm:pm_bin"
  tool_output_name = "pm"

  visibility = [ ":updates" ]
  testonly = true

  deps = [ ":system_index" ]

  inputs = [ system_index ]

  outputs = [ "$target_out_dir/system.snapshot" ]

  args = [
    "snapshot",
    "--manifest",
    rebase_path(inputs[0], root_build_dir),
    "--output",
    rebase_path(outputs[0], root_build_dir),
  ]
}

# initialize and prepare the package repository.
pm_prepare_publish("prepare_publish") {
  testonly = true
}

# publish all packages to the package repository.
pm_publish("publish") {
  testonly = true
  deps = [
    ":all_package_manifests.list",
    ":prepare_publish",
  ]
  inputs = [ all_package_manifests_list ]
}

group("updates") {
  testonly = true
  deps = [
    ":package_lists",
    ":publish",
    ":root_component_index_metadata",
    ":system_snapshot",
  ]
}

group("bootserver") {
  deps = [ "//tools/bootserver_old:bootserver($host_toolchain)" ]

  host_out_dir = get_label_info(":bogus($host_toolchain)", "root_out_dir")

  metadata = {
    images = [
      {
        archive = true
        name = "bootserver"
        path = rebase_path("$host_out_dir/bootserver", root_build_dir)
        type = "exe.$host_platform"
      },
    ]
  }
}

copy("fastboot") {
  sources = [ "//prebuilt/third_party/fastboot/fastboot" ]
  host_out_dir = get_label_info(":bogus($host_toolchain)", "root_out_dir")
  outputs = [ "$host_out_dir/fastboot" ]

  metadata = {
    tool_paths = [
      {
        cpu = host_cpu
        label = get_label_info(":fastboot", "label_with_toolchain")
        name = "fastboot"
        os = host_os
        path = rebase_path(outputs[0], root_build_dir)
      },
    ]

    images = [
      {
        archive = true
        name = "fastboot"
        path = rebase_path(outputs[0], root_build_dir)
        type = "exe.$host_platform"
      },
    ]
  }
}

group("archive-extras") {
  deps = [
    ":build_args_metadata",
    ":flash_script_archive",
  ]
}

group("build_args_metadata") {
  metadata = {
    # Not actually images, but historically required entries to be included in
    # the relevant build archives.
    images = [
      {
        archive = true
        name = "buildargs"
        type = "gn"
        path = "args.gn"
      },
    ]
  }
}

# Build the UEFI disk image.
# GCE, a consumer of this image, requires it to be named disk.raw
uefi_disk_path = "$target_out_dir/disk.raw"
compiled_action("uefi-disk") {
  deps = uefi_disk_deps
  testonly = true
  tool = "//tools/make-fuchsia-vol"
  args = [
    "-fuchsia-build-dir",
    rebase_path("$root_build_dir"),
    "-resize",
    "10000000000",  # 10GB
  ]

  if (bootfs_only) {
    args += [ "-ramdisk-only" ]
  }

  args += [ rebase_path(uefi_disk_path) ]
  outputs = [ uefi_disk_path ]

  metadata = {
    images = [
      {
        archive = false
        name = "uefi-disk"
        path = rebase_path(uefi_disk_path, root_build_dir)
        type = "blk"
      },
    ]
  }
}

group("images") {
  testonly = true
  deps = [
    ":build_args_metadata",
    ":default-images",
    "system",
  ]

  if (!bootfs_only) {
    deps += [ ":netboot" ]
  }
}

# The default-images target is a dependency of the top level default
# target when appropriate, and contains the minimum set of images that
# are typical given the requested build configuration.
group("default-images") {
  testonly = true

  deps = [
    ":fastboot",
    ":fastboot_manifest",
    ":flash_script",
    ":qemu-kernel",
    recovery_label,
  ]

  if (recovery_is_zedboot) {
    deps += [
      ":bootserver",
      ":paver-script",
      ":zedboot-script",
    ]
  }

  if (build_uefi_disk) {
    deps += [ ":uefi-disk" ]
  }

  if (enable_netboot) {
    deps += [ ":netboot-script" ]
  }

  # XXX(46415): The build graph for "bringup" (bootfs_only) MUST only
  # contain one zircon-a metadata target, which means that anything
  # reaching fuchsia.zbi must be excluded from the build graph.
  if (!bootfs_only) {
    deps += [
      ":record_filesystem_sizes",
      ":root_component_index_metadata",
      ":updates",
      "recovery",
    ]
  }
}

generated_file("image_paths") {
  testonly = true
  outputs = [ "$root_build_dir/image_paths.sh" ]
  output_conversion = "list lines"
  data_keys = [ "image_paths" ]
  deps = [ ":images" ]
}