blob: ee12459e93a7d7300dd5fc86768de739369b786e [file] [log] [blame]
# Copyright 2019 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/assembly/compare_image_assembly_configs.gni")
import("//build/assembly/compare_json_list.gni")
import("//build/assembly/generated_image_assembly_config.gni")
import("//build/assembly/generated_images_config.gni")
import("//build/assembly/hermetic_inputs_for_image_assembly.gni")
import("//build/assembly/legacy_assembly_input_bundle.gni")
import("//build/component/component_id_index.gni")
import("//build/config.gni")
import("//build/drivers/driver_manifest.gni")
import("//build/images/fvm.gni")
import("//build/images/shell_commands.gni")
import("//build/info/info.gni")
import("//build/packages/package_metadata.gni")
import("//build/zircon/tools.gni")
import("//src/developer/ffx/build/ffx_action.gni")
import("//src/storage/fshost/generated_fshost_config.gni")
# Assembles a Fuchsia system.
#
# Given base, cache, and universe packages, assembles a Fuchsia system
# containing those packages.
#
# Parameters:
#
# image_name (optional; default: target_name)
# [string] A name to use for naming all outputs and generated files, instead
# of $target_name.
#
# output_dir (optional; default: target_out_dir)
# [string] The output directory into which the final system ZBI is written.
#
# output_name (optional; default: <target_name>.zbi)
# [string] The name of the final system ZBI file.
#
# testonly (optional)
# [bool] Usual GN meanings.
#
# Product parameters:
#
# product_assembly_config_file (optional)
# [file] A path to a product assembly config file. If not specified, a
# placeholder file will be generated and used.
#
# product_assembly_config_dep (optional)
# [label] A label for the above product assembly config, if it's the output
# of a build action.
#
# base_packages (required)
# [list of labels] The packages to include in the base package set.
#
# base_driver_packages (optional)
# [list of labels] The driver packages to include in the base package set.
#
# cache_packages (optional)
# [list of labels] The packages to cache in the images.
#
# universe_packages (optional)
# [list of labels] The packages to build in addition to the base and cache
# sets. These packages do not contribute to the produced images directly,
# however they may contribute to the config-data and shell-commands meta
# packages.
#
# meta_packages (optional)
# [list of labels] The packages to build in addition to the base and cache
# sets, but are base_packages themselves. These are packages that contain
# files that are generated based on other packages in the base, cache,
# and/or universe sets, and therefore cannot be part of those sets directly,
# or a GN dependency cycle will result.
#
# bootfs_labels (required)
# [list of labels] The objects installed on the bootfs partition of the
# generated ZBI.
#
# bootfs_package_labels (optional)
# [list of labels] The packages installed on the bootfs partition of the
# generated ZBI as meta.fars and content-id'd blobs.
#
# system_image_deps (optional)
# [list of labels] The objects installed in the system image.
#
# devmgr_config (default: [])
# [list of strings] List of arguments to add to /boot/config/devmgr.
# These arguments come after synthesized arguments to configure blobfs.
#
# fshost_config (default: {})
# [scope] Arguments to add to fshost's configuration. These
# arguments come before other arguments set by build args.
#
# cmdline (optional)
# [list of strings] Kernel command line text.
#
# cmdline_deps (optional)
# [list of labels] Dependencies with metadata including additional kernel
# command arguments to add to the ZBI.
#
# include_component_id_index (default: false)
# [bool] Collect and merges a component id index from the base
# package set.
#
# include_shell_commands (default: true)
# [bool] Whether to include shell commands. Should be set to false for
# build without shell access.
#
# include_config_data (default: true)
# [bool] Whether to create a config_data package for the assembly or not.
#
# base_package_name (optional; default: "system_image")
# [string] The name to give the base package. For prime builds this
# should be "system_image_prime", so that the package does not override the
# non-prime package during publishing.
#
# Board parameters:
#
# assembly_compress_blobs (default: true)
# [boolean] Whether the blobs added to the blobfs image should be compressed.
#
# assembly_blob_layout_format (default: "compact")
# [string] The format blobfs should store blobs in. The valid values are "deprecated_padded" and
# "compact". The deprecated padded format is supported only for Astro devices and will be
# removed in the future (it wastes space).
#
# check_production_tag (default: false)
# [bool] Whether to check there is no non_production_tag dependencies.
#
# Board: MinFS parameters:
#
# minfs_minimum_data_bytes, minfs_maximum_bytes (optional)
# [int] Size options for minfs to pass to the fvm tool.
#
# Board: BlobFS parameters
#
# blobfs_minimum_inodes, blobfs_minimum_data_bytes, blobfs_maximum_bytes, blobfs_maximum_contents_size (optional)
# [int] Size options for blobfs to pass to the fvm tool.
#
# Board: FVM parameters
#
# generate_fvm (optional; default: true)
# [bool] Whether to generate a FVM image.
#
# assembly_include_account_in_fvm (optional; default: false)
# [bool] Whether to include an account partition in the FVM image.
#
# ramdisk_fvm_in_zbi (optional)
# [bool] Whether the FVM should be embedded into the ZBI as a ramdisk.
#
# assembly_fvm_slice_size (optional; default: 1048576)
# [int] The slice size of the FVM.
#
# fvm_truncate_to_length (optional)
# [int] The precise size to make the (non-sparse) FVM image. See
# documentation of the `--length` parameter of the `fvm` binary host tool
# for details.
#
# Board: ZBI arguments
#
# zbi_name (optional; default: target_name)
# [string] The name to give the ZBI in the out directory.
# Typically: fuchsia, recovery, etc.
#
# zbi_signing_script (optional)
# [path] Location of script to use to sign the ZBI.
#
# zbi_signing_args (optional)
# [list of strings] Arguments to pass to the signing script.
#
# zbi_signing_script_deps (optional)
# [list of labels] Dependencies needed by the signing script.
#
template("assembled_system") {
assert(defined(invoker.base_packages), "Need to define base_packages")
assert(defined(invoker.bootfs_labels), "Need to define bootfs_labels")
if (defined(invoker.product_assembly_config_dep)) {
assert(
invoker.product_assembly_config_dep != "",
"'product_assembly_config_dep' cannot be an empty string. Don't provide a value if it is not being used.")
assert(defined(invoker.product_assembly_config_file),
"Need to define a 'product_assembly_config_file'.")
}
if (defined(invoker.product_assembly_config_file)) {
assert(
invoker.product_assembly_config_file != "",
"'product_assembly_config_file' cannot be an empty string. Don't provide a value if it is not being used.")
}
fvm_tool_target = "//src/storage/bin/fvm($host_toolchain)"
fvm_tool_path = get_label_info(fvm_tool_target, "root_out_dir")
fvm_tool_path += "/fvm"
# This should be removed once all clients are no longer supplying board_name.
not_needed(invoker, [ "board_name" ])
image_name = target_name
if (defined(invoker.image_name)) {
image_name = invoker.image_name
}
base_package_name = "system_image"
if (defined(invoker.base_package_name)) {
base_package_name = invoker.base_package_name
}
# Internal labels used for Image Assembly.
labels = {
base_packages_group = "${image_name}.base_packages"
cache_packages_group = "${image_name}.cache_packages"
meta_packages_group = "${image_name}.meta_packages"
all_packages_group = "${image_name}.packages"
legacy_assembly_input_bundle = "${image_name}.legacy_input_bundle"
if (defined(invoker.product_assembly_config_dep)) {
product_assembly_config_deps = [ invoker.product_assembly_config_dep ]
} else {
product_assembly_config_deps = []
}
image_assembly_config = "${image_name}.image_assembly_config"
image_assembly_inputs = "${image_name}.image_assembly_inputs"
compare_image_assembly_configs =
"${image_name}.compare_image_assembly_configs"
images_config = "${image_name}.images_config"
product_assembler = "${image_name}.product_assembler"
image_assembler = "${image_name}.image_assembler"
copy_vbmeta = "${image_name}.copy_vbmeta"
copy_zbi = "${image_name}.copy_zbi"
copy_zbi_signed = "${image_name}.copy_zbi_signed"
copy_zbi_manifest = "${image_name}.copy_zbi_manifest"
copy_images = "${image_name}.copy_images"
config_data = "${image_name}.config-data"
shell_commands = "${image_name}.shell_commands"
fshost_config = "${image_name}.fshost_config"
compare_command_logs = "${image_name}.compare_command_logs"
compare_images_manifests = "${image_name}.compare_images_manifests"
platform_aib = "//build/assembly"
}
# Intermediate files produced for Image Assembly.
files = {
if (defined(invoker.product_assembly_config_file)) {
product_assembly_config = invoker.product_assembly_config_file
} else {
product_assembly_config = "//build/assembly/empty_product_config.json"
}
image_assembly_config =
"$target_out_dir/${image_name}.image_assembly_config.json"
image_assembly_inputs =
"$target_out_dir/${image_name}.image_assembly_inputs"
images_config = "$target_out_dir/${image_name}.images_config.json"
outdir = "$target_out_dir/$image_name"
gendir = "$outdir/gen"
legacy_assembly_input_bundle_manifest =
"${outdir}/legacy/assembly_config.json"
platform_aib_dir = get_label_info(labels.platform_aib, "target_out_dir")
emulator_aib_manifest =
"$platform_aib_dir/emulator_support/assembly_config.json"
# This file is created implicitly by ffx assembly product, so this is the
# path that it's expected to be found at, not the path that it's to be
# written to.
regenerated_image_assembly_config = "${outdir}/image_assembly.json"
config_data_manifest = "${outdir}/config_data/package_manifest.json"
compare_image_assembly_configs =
"${outdir}/compare_image_assembly_configs.verified"
bootfs_files = "${gendir}/bootfs_files.list"
devmgr_config = "${gendir}/devmgr_config.txt"
zbi = "${outdir}/${image_name}.zbi"
zbi_signed = "${zbi}.signed"
vbmeta = "${outdir}/${image_name}.vbmeta"
minfs = "${outdir}/data.blk"
blobfs = "${outdir}/blob.blk"
fvm = "${outdir}/fvm.blk"
fvm_sparse = "${outdir}/fvm.sparse.blk"
fvm_blob_sparse = "${outdir}/fvm.blob.sparse.blk"
fvm_fastboot_tmp = "${outdir}/fvm.fastboot.tmp.blk"
fvm_fastboot = "${outdir}/fvm.fastboot.blk"
base_package = "${outdir}/base/meta.far"
base_package_manifest = "${outdir}/base/package_manifest.json"
base_package_merkle = "${outdir}/base/base.merkle"
packages = "${outdir}/packages.json"
zbi_manifest = "${gendir}/zbi.json"
blobfs_manifest = "${gendir}/blob.manifest"
blobs_json = "${gendir}/blobs.json"
bootfs_packages = "${gendir}/data/bootfs_packages"
static_packages = "${gendir}/${base_package_name}/data/static_packages"
cache_packages = "${gendir}/${base_package_name}/data/cache_packages.json"
base_meta_package = "${gendir}/${base_package_name}/meta/package"
base_pkg_abi_revision =
"${gendir}/${base_package_name}/meta/fuchsia.abi/abi-revision"
images_manifest = "${outdir}/images.json"
image_command_log = "${gendir}/command_log.json"
# Determine which ZBI we are shipping.
zbi_final = zbi
if (defined(invoker.zbi_signing_script)) {
zbi_final = zbi_signed
}
}
_base_packages = invoker.base_packages
_base_driver_packages = []
_cache_packages = []
_universe_packages = []
_meta_packages = []
if (defined(invoker.base_driver_packages)) {
_base_driver_packages = invoker.base_driver_packages
}
_base_packages += _base_driver_packages
if (defined(invoker.cache_packages)) {
_cache_packages = invoker.cache_packages
}
if (defined(invoker.universe_packages)) {
_universe_packages = invoker.universe_packages
}
if (defined(invoker.meta_packages)) {
_meta_packages = invoker.meta_packages
}
generate_fvm = true
if (defined(invoker.generate_fvm)) {
generate_fvm = invoker.generate_fvm
}
system_image_deps = []
if (defined(invoker.system_image_deps) && generate_fvm) {
system_image_deps += invoker.system_image_deps
} else {
not_needed(invoker, [ "system_image_deps" ])
}
embed_fvm_in_zbi = false
if (defined(invoker.ramdisk_fvm_in_zbi)) {
embed_fvm_in_zbi = invoker.ramdisk_fvm_in_zbi && generate_fvm
}
devmgr_config = []
if (defined(invoker.devmgr_config)) {
devmgr_config = invoker.devmgr_config
}
fshost_config = {
}
if (defined(invoker.fshost_config)) {
fshost_config = invoker.fshost_config
}
include_shell_commands = true
if (defined(invoker.include_shell_commands)) {
include_shell_commands = invoker.include_shell_commands
}
# Generate the base driver manifest file that lists all available drivers
# collected from _base_driver_packages dependency tree. This manifest file
# will be included in the driver-manager-base-config package.
base_driver_manifest_label = "${image_name}.base-driver-manifest"
combined_driver_manifest(base_driver_manifest_label) {
forward_variables_from(invoker, [ "testonly" ])
manifest_name = "base-driver-manifest.json"
deps = _base_driver_packages
}
# The driver-manager-base-config package is read by Driver Manager to
# discover where the base drivers are located.
driver_manager_base_config_label = "${image_name}.driver-manager-base-config"
fuchsia_package(driver_manager_base_config_label) {
forward_variables_from(invoker,
[
"testonly",
"visibility",
])
package_name = "driver-manager-base-config"
deps = [ ":${base_driver_manifest_label}" ]
}
_meta_packages += [ ":${driver_manager_base_config_label}" ]
# TODO(fxbug.dev/81290): Construct the shell commands package in the Image
# Assembler.
if (include_shell_commands) {
shell_commands(labels.shell_commands) {
forward_variables_from(invoker,
[
"testonly",
"visibility",
])
package_name = "shell-commands"
deps = _base_packages + _cache_packages + _universe_packages
}
_meta_packages += [ ":${labels.shell_commands}" ]
} else {
not_needed([ "_universe_packages" ])
}
component_id_index_dep = []
component_id_index_config_data_dep = []
include_component_index = defined(invoker.include_component_id_index) &&
invoker.include_component_id_index
if (include_component_index) {
# For details, see //docs/development/components/component_id_index.md#system-assembly
component_id_index_config("${image_name}.component_id_index_config") {
forward_variables_from(invoker,
[
"testonly",
"visibility",
])
# collect and merge component ID indices from the base set.
deps = _base_packages
metadata = {
package_barrier = []
}
}
component_id_index_dep = [ ":${image_name}.component_id_index_config" ]
component_id_index_config_data_dep =
[ ":${image_name}.component_id_index_config-config-data" ]
_meta_packages += component_id_index_dep
}
include_config_data = true
if (defined(invoker.include_config_data)) {
include_config_data = invoker.include_config_data
}
if (include_config_data) {
config_package(labels.config_data) {
forward_variables_from(invoker,
[
"testonly",
"visibility",
])
package_name = "config-data"
deps = _base_packages + _universe_packages + _cache_packages +
component_id_index_config_data_dep
}
_meta_packages += [ ":${labels.config_data}" ]
}
generated_fshost_config(labels.fshost_config) {
options = fshost_config
if (embed_fvm_in_zbi) {
fvm_ramdisk = true
}
}
# Create GN groups for each of the package sets.
group(labels.base_packages_group) {
forward_variables_from(invoker, [ "testonly" ])
public_deps = _base_packages
}
group(labels.cache_packages_group) {
forward_variables_from(invoker, [ "testonly" ])
public_deps = _cache_packages
}
# The group of generated packages that contain files that depend on metadata
# walks of the base/cache/universe package sets and therefore cannot be part
# of those package sets.
group(labels.meta_packages_group) {
forward_variables_from(invoker, [ "testonly" ])
public_deps = _meta_packages
}
#######
# Build the images using the Image Assembler.
#
generated_image_assembly_config(labels.image_assembly_config) {
forward_variables_from(invoker,
[
"testonly",
"visibility",
])
output_path = files.image_assembly_config
kernel_image = "//zircon/kernel"
base_packages = []
if (generate_fvm) {
base_packages = _base_packages
base_packages += _meta_packages
cache_packages = _cache_packages
}
boot_args = devmgr_config
# Search for BootFS packages in these targets.
bootfs_package_labels = []
if (defined(invoker.bootfs_package_labels)) {
bootfs_package_labels += invoker.bootfs_package_labels
}
# Search for BootFS files in these targets.
bootfs_labels = invoker.bootfs_labels
bootfs_labels += component_id_index_dep
bootfs_labels += [ "//zircon/kernel" ]
bootfs_labels += [ ":${labels.fshost_config}" ]
# Only builds with an FVM need base-resolver/pkg-cache-resolver.
if (generate_fvm) {
bootfs_labels += [ "//src/sys/base-resolver:bootfs" ]
}
# If not building an FVM, then put the driver_manager config into bootfs
if (!generate_fvm) {
bootfs_labels += [ ":${driver_manager_base_config_label}" ]
}
extra_base_deps = system_image_deps
# Search for the Kernel cmdline in the BootFS dependencies.
cmdline_deps = invoker.bootfs_labels
if (defined(invoker.cmdline_deps)) {
cmdline_deps += invoker.cmdline_deps
}
if (defined(invoker.cmdline)) {
cmdline = invoker.cmdline
}
}
generated_images_config(labels.images_config) {
forward_variables_from(invoker,
[
"testonly",
"visibility",
"zbi_signing_script",
"zbi_signing_args",
"minfs_maximum_bytes",
"minfs_minimum_data_bytes",
"blobfs_maximum_bytes",
"blobfs_minimum_data_bytes",
"blobfs_maximum_contents_size",
"blobfs_minimum_inodes",
"fvm_truncate_to_length",
])
output_path = files.images_config
zbi_name = "${image_name}"
fvm_reserved_slices = fvm_reserved_slices
generate_fvm = generate_fvm
fvm_slice_size = 1048576
if (defined(invoker.assembly_fvm_slice_size)) {
fvm_slice_size = invoker.assembly_fvm_slice_size
}
blob_layout_format = "compact"
if (defined(invoker.assembly_blob_layout_format)) {
blob_layout_format = invoker.assembly_blob_layout_format
}
compress_blobs = true
if (defined(invoker.assembly_compress_blobs)) {
compress_blobs = invoker.assembly_compress_blobs
}
if (defined(invoker.assembly_include_account_in_fvm)) {
empty_account_partition = invoker.assembly_include_account_in_fvm
}
}
check_production_tag = false
if (defined(invoker.check_production_tag)) {
check_production_tag = invoker.check_production_tag
}
# Create the legacy assembly input bundle for the above-generated image
# assembly configuration.
legacy_assembly_input_bundle(labels.legacy_assembly_input_bundle) {
forward_variables_from(invoker,
[
"testonly",
"visibility",
])
image_assembly_label = ":${image_name}"
bundles_dir = files.outdir
include_config_data = generate_fvm
create_package = defined(invoker.create_legacy_aib_package) &&
invoker.create_legacy_aib_package
create_package_archive = defined(invoker.create_legacy_aib_archive) &&
invoker.create_legacy_aib_archive
}
# Run product assembly.
ffx_action(labels.product_assembler) {
forward_variables_from(invoker,
[
"testonly",
"visibility",
])
# TODO(fxbug.dev/77290) - Add depfile support and then remove the following
hermetic_deps = false
args = [
"--config",
"assembly_enabled=true",
"assembly",
"product",
"--product",
rebase_path(files.product_assembly_config, root_build_dir),
"--input-bundles-dir",
rebase_path(files.platform_aib_dir, root_build_dir),
"--legacy-bundle-dir",
rebase_path(files.outdir, root_build_dir),
"--outdir",
rebase_path(files.outdir, root_build_dir),
]
deps = [
":${labels.legacy_assembly_input_bundle}",
labels.platform_aib,
] + labels.product_assembly_config_deps
inputs = [
files.emulator_aib_manifest,
files.legacy_assembly_input_bundle_manifest,
files.product_assembly_config,
]
outputs = [ files.regenerated_image_assembly_config ]
# If there isn't an FVM, there won't be a config-data package, and so it
# won't be created by product assembly (it won't have any config data in
# the legacy or common configs.)
if (generate_fvm) {
outputs += [ files.config_data_manifest ]
}
}
# Validate that the generated image assembly configuration matches the
# legacy + the product assembly configuration.
compare_image_assembly_configs(labels.compare_image_assembly_configs) {
forward_variables_from(invoker, [ "testonly" ])
deps = [
":${labels.image_assembly_config}",
":${labels.product_assembler}",
] + labels.product_assembly_config_deps
legacy_image_assembly_config = files.image_assembly_config
generated_image_assembly_config = files.regenerated_image_assembly_config
product_assembly_config = files.product_assembly_config
}
hermetic_inputs_for_image_assembly(labels.image_assembly_inputs) {
forward_variables_from(invoker,
[
"testonly",
"visibility",
])
deps = [
":${labels.images_config}",
":${labels.product_assembler}",
]
image_assembly_config = files.regenerated_image_assembly_config
images_config = files.images_config
output = files.image_assembly_inputs
}
ffx_action(labels.image_assembler) {
no_output_dir_leaks = false
forward_variables_from(invoker,
[
"testonly",
"visibility",
])
metadata = {
# We insert these barriers to prevent the dependencies of these images
# from leaking into images "higher up" in the dependency chain.
package_barrier = []
config_package_barrier = []
distribution_entries_barrier = []
if (defined(invoker.metadata)) {
forward_variables_from(invoker.metadata, "*")
}
if (generate_fvm) {
package_output_manifests = [ files.base_package_manifest ]
}
}
hermetic_inputs_target = ":${labels.image_assembly_inputs}"
hermetic_inputs_file = files.image_assembly_inputs
args = [
"--config",
"assembly_enabled=true",
"assembly",
"create-system",
"--image-assembly-config",
rebase_path(files.regenerated_image_assembly_config, root_build_dir),
"--images",
rebase_path(files.images_config, root_build_dir),
"--base-package-name",
"$base_package_name",
"--gendir",
rebase_path(files.gendir, root_build_dir),
"--outdir",
rebase_path(files.outdir, root_build_dir),
]
if (embed_fvm_in_zbi) {
args += [
"--mode",
"fvm-in-zbi",
]
} else if (!generate_fvm) {
args += [
"--mode",
"bootfs",
]
}
deps = []
if (defined(invoker.deps)) {
deps += invoker.deps
}
deps += [
":${labels.images_config}",
":${labels.product_assembler}",
]
# Set the deps needed in order to run the zbi_signing_script
if (defined(invoker.zbi_signing_script_deps)) {
deps += invoker.zbi_signing_script_deps
}
inputs = [
files.images_config,
files.regenerated_image_assembly_config,
]
if (defined(invoker.inputs)) {
inputs += invoker.inputs
}
outputs = [
files.bootfs_files,
files.devmgr_config,
files.zbi,
files.zbi_manifest,
files.packages,
files.bootfs_packages,
files.image_command_log,
files.images_manifest,
]
if (defined(invoker.zbi_signing_script)) {
outputs += [ files.zbi_signed ]
}
if (use_vbmeta) {
outputs += [ files.vbmeta ]
}
# Base package dependencies and outputs, if this configuration uses them.
if (generate_fvm) {
deps += [
blobfs_tool_target,
fvm_tool_target,
]
inputs += [
blobfs_tool_path,
fvm_tool_path,
]
outputs += [
# In the outdir.
files.base_package,
files.base_package_manifest,
files.base_package_merkle,
files.minfs,
files.blobfs,
files.fvm,
files.fvm_sparse,
files.fvm_blob_sparse,
# In the gendir.
files.blobfs_manifest,
files.blobs_json,
files.static_packages,
files.cache_packages,
files.base_meta_package,
files.base_pkg_abi_revision,
]
if (fvm_emmc_partition_size != false ||
fvm_ftl_nand_block_count != false) {
outputs += [ files.fvm_fastboot ]
if (fvm_ftl_nand_block_count != false) {
outputs += [ files.fvm_fastboot_tmp ]
}
}
}
if (check_production_tag) {
assert_no_deps = [ "//build/validate:non_production_tag" ]
}
}
#######
# Optionally, copy the resulting ZBI to the specified directory.
#
if (defined(invoker.output_dir)) {
assert(
invoker.output_dir != target_out_dir,
"The specified output directory must be different from the default target_out_dir")
# The output name is the same as the original file by default.
# Otherwise, it takes the output_name, and strips any extension.
output_name = "${image_name}"
if (defined(invoker.output_name)) {
parts = string_split(invoker.output_name, ".")
output_name = parts[0]
}
copy(labels.copy_zbi) {
forward_variables_from(invoker,
[
"testonly",
"visibility",
])
sources = [ files.zbi ]
outputs = [ "${invoker.output_dir}/${output_name}.zbi" ]
deps = [ ":${labels.image_assembler}" ]
}
copy(labels.copy_zbi_manifest) {
forward_variables_from(invoker,
[
"testonly",
"visibility",
])
sources = [ files.zbi_manifest ]
outputs = [ "${invoker.output_dir}/${output_name}.zbi.json" ]
deps = [ ":${labels.image_assembler}" ]
}
if (defined(invoker.zbi_signing_script)) {
copy(labels.copy_zbi_signed) {
forward_variables_from(invoker,
[
"testonly",
"visibility",
])
sources = [ files.zbi_signed ]
outputs = [ "${invoker.output_dir}/${output_name}.zbi.signed" ]
deps = [ ":${labels.image_assembler}" ]
}
}
if (use_vbmeta) {
copy(labels.copy_vbmeta) {
forward_variables_from(invoker,
[
"testonly",
"visibility",
])
sources = [ files.vbmeta ]
outputs = [ "${invoker.output_dir}/${output_name}.vbmeta" ]
deps = [ ":${labels.image_assembler}" ]
}
}
group(labels.copy_images) {
forward_variables_from(invoker,
[
"testonly",
"visibility",
])
public_deps = [
":${labels.copy_zbi_manifest}",
":${labels.copy_zbi}",
]
if (defined(invoker.zbi_signing_script)) {
public_deps += [ ":${labels.copy_zbi_signed}" ]
}
if (use_vbmeta) {
public_deps += [ ":${labels.copy_vbmeta}" ]
}
}
}
#######
# Check the golden files.
#
# TODO(fxbug.dev/101283): These checks are no longer a part of
# `assembled_system()`. Remove `not_needed(...)` once all build configurations
# no longer specify scrutiny verifier configuration.
not_needed(invoker,
[
"cmdline_goldens",
"bootfs_goldens",
"static_pkgs_goldens",
"route_sources_config",
])
group(target_name) {
forward_variables_from(invoker,
[
"testonly",
"visibility",
])
# public_deps is used, so that the outputs of these dependencies are
# available to external targets.
public_deps = [
":${labels.compare_image_assembly_configs}",
":${labels.image_assembler}",
":${labels.image_assembly_config}",
":${labels.images_config}",
]
if (defined(invoker.output_dir)) {
public_deps += [ ":${labels.copy_images}" ]
}
metadata = {
# Assemblies have some defined packages, such as the base package.
# This barrier prevents a Assembly#1 from including a depending Assembly#2
# packages in the package sets (base, cache, system) for Assembly#1.
assembly_package_barrier = []
assembly_inputs_barrier = []
}
}
}