| # 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/config/clang/clang.gni") |
| import("//build/config/fuchsia/bootdata.gni") |
| import("//build/gn/packages.gni") |
| import("//build/images/boot.gni") |
| import("//build/images/manifest.gni") |
| import("//build/package.gni") |
| import("//build/sdk/sdk_atom.gni") |
| import("//garnet/go/src/amber/amber.gni") |
| |
| ### |
| ### Zircon BOOTFS and kernel command-line BOOTDATA images. These are not |
| ### directly usable, but they capture all the Zircon bits and are ready to |
| ### be combined with a system image to make a complete image. |
| ### |
| |
| declare_args() { |
| # File containing kernel command line arguments to roll into the |
| # bootdata image used for booting. |
| kernel_cmdline_file = "" |
| |
| # Groups to include from the Zircon /boot manifest into /boot. |
| # This is either "all" or a comma-separated list of one or more of: |
| # core -- necessary to boot |
| # misc -- utilities in /bin |
| # test -- test binaries in /bin and /test |
| zircon_boot_groups = "core" |
| } |
| |
| declare_args() { |
| # Groups to include from the Zircon /boot manifest into /system |
| # (instead of into /boot like Zircon's own bootdata.bin does). |
| # Should not include any groups that are also in zircon_boot_groups, |
| # which see. If zircon_boot_groups is "all" then this should be "". |
| if (zircon_boot_groups == "all") { |
| zircon_system_groups = "" |
| } else { |
| # TODO(mcgrathr): Could default to "" for !is_debug, or "production |
| # build". Note including "test" here places all of Zircon's tests |
| # into /system/test, which means that Fuchsia bots run those tests |
| # too. |
| zircon_system_groups = "misc,test" |
| } |
| } |
| |
| # image_paths aggregates a list of environment variable style strings of the form: |
| # IMAGE_{NAME}_{TYPE}=path |
| # path is relative to $root_build_dir. |
| # This will be written out at generation time and is later consumed by |
| # //scripts and various tools to find the relevant images. |
| # TYPE can be: SPARSE (sparse FVM), RAW (block image for any FS), ZBI (bootable |
| # zircon image), RAM (ramdisk without kernel), VBOOT (bootable zircon image |
| # with a vboot signature). |
| image_paths = [] |
| |
| if (zircon_boot_groups == "all") { |
| assert(zircon_system_groups == "", |
| "zircon_boot_groups already has everything") |
| } else { |
| assert(zircon_system_groups != "all" && zircon_system_groups != "core", |
| "zircon_system_groups cannot include core (or all)") |
| } |
| |
| # Generate the manifest of pure Zircon components going into /boot. |
| generate_manifest("boot.manifest") { |
| visibility = [ ":*" ] |
| zircon_groups = zircon_boot_groups |
| args = [] |
| } |
| |
| boot_manifest_outputs = get_target_outputs(":boot.manifest") |
| boot_manifest = boot_manifest_outputs[0] |
| boot_build_id_map = boot_manifest_outputs[1] |
| |
| # Generate a BOOTDATA container of the compressed BOOTFS image for /boot. |
| # It only has to be compressed once, and then this container is combined |
| # with more BOOTDATA below to make specific images for booting. |
| bootdata("boot") { |
| visibility = [ ":*" ] |
| boot = true |
| deps = [ |
| ":boot.manifest", |
| ] |
| inputs = [ |
| boot_manifest, |
| ] |
| } |
| |
| # Inject fixed kernel command-line arguments maintained in the source tree. |
| bootdata_cmdline("cmdline") { |
| visibility = [ ":*" ] |
| inputs = [ |
| "cmdline.txt", |
| ] |
| } |
| |
| # Let the build configuration choose some extra fixed command-line arguments. |
| if (kernel_cmdline_file != "") { |
| bootdata_cmdline("extra_cmdline") { |
| visibility = [ ":*" ] |
| inputs = [ |
| kernel_cmdline_file, |
| ] |
| } |
| } |
| |
| # This makes the complete Zircon BOOTDATA image (sans the kernel itself). |
| # This includes the /boot filesystem and the fixed kernel command line |
| # settings from the build (cmdline.txt and build argument |
| # `kernel_cmdline_file`). |
| bootdata("bootdata") { |
| deps = [ |
| ":boot", |
| ":cmdline", |
| ] |
| if (kernel_cmdline_file != "") { |
| deps += [ ":extra_cmdline" ] |
| } |
| inputs = [] |
| foreach(label, deps) { |
| inputs += get_target_outputs(label) |
| } |
| } |
| |
| ### |
| ### Fuchsia system image. This aggregates contributions from all the |
| ### package() targets enabled in the build. |
| ### |
| |
| pm_binary_label = "//garnet/go/src/pm:pm_bin($host_toolchain)" |
| pm_out_dir = get_label_info(pm_binary_label, "root_out_dir") |
| pm_binary = "$pm_out_dir/pm" |
| |
| # This just runs `pm -k $system_package_key genkey` if the file doesn't exist. |
| # Every package() target depends on this. |
| action("system_package_key_check") { |
| visibility = [ "*" ] |
| deps = [ |
| pm_binary_label, |
| ] |
| outputs = [ |
| "$target_out_dir/system_package_key_check_ok.stamp", |
| ] |
| script = "//build/gn_run_binary.sh" |
| inputs = [ |
| "system_package_key_check.py", |
| pm_binary, |
| ] |
| args = |
| [ clang_prefix ] + rebase_path(inputs + outputs + [ system_package_key ]) |
| } |
| |
| # 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", ":update_packages.manifest" ] |
| testonly = true |
| |
| script = "manifest.py" |
| args = [ "--contents" ] |
| outputs = [ |
| "$target_out_dir/$target_name", |
| ] |
| args += [ "--output=" + rebase_path(outputs[0], root_build_dir) ] |
| sources = [] |
| deps = [] |
| foreach(pkg_label, package_targets) { |
| # Find the response file written by package(). |
| pkg_target_name = get_label_info(pkg_label, "name") |
| pkg_target_out_dir = get_label_info(pkg_label, "target_out_dir") |
| pkg_rspfile = "$pkg_target_out_dir/${pkg_target_name}.pkgsvr_index.rsp" |
| deps += [ "${pkg_label}.pkgsvr_index.rsp" ] |
| sources += [ pkg_rspfile ] |
| args += [ "@" + rebase_path(pkg_rspfile, root_build_dir) ] |
| } |
| } |
| |
| # The system_image "package" manifest is everything that appears in /system. |
| generate_manifest("system_image.manifest") { |
| visibility = [ ":*" ] |
| testonly = true |
| |
| # First we take the /boot manifest as a "dummy". This means that its |
| # libraries are used to resolve references from binaries going into |
| # the output manifest (below) with the assumption that they'll be |
| # available to dynamic linking at runtime, but none of the files from |
| # the /boot manifest actually go into the output. |
| dummy_deps = [ ":boot.manifest" ] |
| |
| # Collect whatever we want from Zircon that didn't go into /boot. |
| zircon_groups = zircon_system_groups |
| |
| # 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). |
| args = [] |
| deps = [] |
| sources = [] |
| foreach(pkg_label, package_targets) { |
| # Find the response file written by package(). |
| pkg_target_name = get_label_info(pkg_label, "name") |
| pkg_target_out_dir = get_label_info(pkg_label, "target_out_dir") |
| pkg_system_rsp = "$pkg_target_out_dir/${pkg_target_name}.system.rsp" |
| deps += [ pkg_label ] |
| sources += [ pkg_system_rsp ] |
| args += [ "@" + rebase_path(pkg_system_rsp, 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 pkgsvr, required to serve a system image package. |
| pkgsvr_binary_label = "//garnet/go/src/pmd:pkgsvr_bin" |
| deps += [ pkgsvr_binary_label ] |
| sources += [ get_label_info(pkgsvr_binary_label, "root_out_dir") + "/pkgsvr" ] |
| } |
| |
| system_manifest_outputs = get_target_outputs(":system_image.manifest") |
| system_manifest = system_manifest_outputs[0] |
| system_build_id_map = system_manifest_outputs[1] |
| |
| # Generate, sign, and seal the system_image package file. |
| pm_build_package("system_image.meta") { |
| visibility = [ ":*" ] |
| testonly = true |
| 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 = "$root_build_dir/blob.manifest" |
| |
| action("blob.manifest") { |
| visibility = [ ":*" ] |
| testonly = true |
| deps = [ |
| ":system_image.manifest", |
| ":system_image.meta", |
| ] |
| outputs = [ |
| blob_manifest, |
| ] |
| inputs = [ |
| system_manifest, |
| ] |
| script = "manifest.py" |
| args = [ "@{{response_file_name}}" ] |
| response_file_contents = [ |
| "--sources", |
| "--output=" + rebase_path(blob_manifest, root_build_dir), |
| "--manifest=" + rebase_path(system_manifest, root_build_dir), |
| "--entry=system_image/meta.far=" + |
| rebase_path("$target_out_dir/system_image.meta/meta.far", |
| root_build_dir), |
| ] |
| foreach(pkg_label, package_targets) { |
| pkg_target_name = get_label_info(pkg_label, "name") |
| pkg_target_out_dir = get_label_info(pkg_label, "target_out_dir") |
| pkg_blob_rsp = "$pkg_target_out_dir/${pkg_target_name}.blob.rsp" |
| deps += [ "${pkg_label}.blob.rsp" ] |
| inputs += [ pkg_blob_rsp ] |
| response_file_contents += |
| [ "@" + rebase_path(pkg_blob_rsp, root_build_dir) ] |
| } |
| } |
| |
| # Pack up all the blobs! |
| zircon_tool_action("blob.blk") { |
| visibility = [ |
| ":fvm.blk", |
| ":fvm.sparse.blk", |
| ] |
| testonly = true |
| deps = [ |
| ":blob.manifest", |
| ] |
| blob_image_path = "$images_dir/$target_name" |
| outputs = [ |
| blob_image_path, |
| ] |
| inputs = [ |
| blob_manifest, |
| ] |
| tool = "blobfs" |
| args = [ |
| rebase_path(blob_image_path), |
| "create", |
| "--manifest", |
| rebase_path(blob_manifest, root_build_dir), |
| ] |
| } |
| blob_raw_image_path = get_target_outputs(":blob.blk") |
| image_paths += [ "IMAGE_BLOB_RAW=" + rebase_path(blob_raw_image_path[0], root_build_dir) ] |
| |
| # Calculate the merkleroots that go into the kernel command line switches. |
| zircon_tool_action("system_image_merkleroots") { |
| visibility = [ ":*" ] |
| testonly = true |
| outputs = [ |
| "$target_out_dir/$target_name", |
| ] |
| pkgsvr_binary_label = "//garnet/go/src/pmd:pkgsvr_bin" |
| deps = [ |
| ":system_image.meta", |
| pkgsvr_binary_label, |
| ] |
| sources = [ |
| get_label_info(pkgsvr_binary_label, "root_out_dir") + "/pkgsvr", |
| "$target_out_dir/system_image.meta/meta.far", |
| ] |
| tool = "merkleroot" |
| args = [ "-o" ] + rebase_path(outputs + sources, root_build_dir) |
| } |
| |
| # Massage that into the kernel command line text for |
| # zircon.system.blob-init and zircon.system.blob-init-arg. |
| action("system_image_cmdline.txt") { |
| visibility = [ ":*" ] |
| testonly = true |
| outputs = [ |
| "$target_out_dir/$target_name", |
| ] |
| deps = [ |
| ":system_image_merkleroots", |
| ] |
| sources = get_target_outputs(":system_image_merkleroots") |
| script = "system_image_cmdline.py" |
| args = rebase_path(outputs + sources, root_build_dir) |
| } |
| |
| # Package that command line up as BOOTDATA. |
| bootdata_cmdline("system_image_cmdline") { |
| visibility = [ ":*" ] |
| testonly = true |
| deps = [ |
| ":system_image_cmdline.txt", |
| ] |
| inputs = get_target_outputs(":system_image_cmdline.txt") |
| } |
| |
| # Combine the /boot, /system, and package build ID maps into one. |
| action("ids.txt") { |
| testonly = true |
| |
| deps = [ |
| ":boot.manifest", |
| ":system_image.manifest", |
| ] |
| sources = [ |
| boot_build_id_map, |
| system_build_id_map, |
| ] |
| |
| foreach(pkg_label, package_targets) { |
| # Find the ids.txt file written by package(). |
| manifest = get_label_info(pkg_label, "label_no_toolchain") + ".manifest" |
| manifest_target_name = get_label_info(manifest, "name") |
| manifest_target_out_dir = get_label_info(manifest, "target_out_dir") |
| deps += [ manifest ] |
| sources += [ "$manifest_target_out_dir/${manifest_target_name}.ids.txt" ] |
| } |
| |
| script = "/usr/bin/sort" |
| outputs = [ |
| "$root_out_dir/ids.txt", |
| ] |
| args = [ |
| "-u", |
| "-o", |
| ] + rebase_path(outputs + sources, root_build_dir) |
| } |
| |
| ### |
| ### Complete images for booting and installing the whole system. |
| ### |
| |
| declare_args() { |
| # The size of the minfs data partition image to create. Normally this image |
| # is added to FVM, and can therefore expand as needed. It must be at least |
| # 10mb (the default) in order to be succesfully initialized. |
| data_image_size = "10m" |
| |
| # The size in bytes of the FVM partition image to create. Normally this is |
| # computed to be just large enough to fit the blob and data images. The |
| # default value is "", which means to size based on inputs. Specifying a size |
| # that is too small will result in build failure. |
| fvm_image_size = "" |
| |
| # Build boot images that prefer Zedboot over local boot. |
| always_zedboot = false |
| } |
| |
| template("generate_fvm") { |
| zircon_tool_action(target_name) { |
| visibility = [ ":*" ] |
| forward_variables_from(invoker, [ "testonly" ]) |
| tool = "fvm" |
| outputs = [ |
| invoker.output_name, |
| ] |
| sources = [] |
| deps = invoker.deps |
| foreach(label, deps) { |
| sources += get_target_outputs(label) |
| } |
| args = rebase_path(outputs, root_build_dir) + invoker.args + |
| rebase_path(sources, root_build_dir) |
| } |
| } |
| |
| fvm_create_args = [ "create" ] |
| |
| fvm_sparse_args = [ |
| "sparse", |
| "--compress", |
| "lz4", |
| ] |
| |
| # fvm.blk creates a non-sparse FVM partition image containing the blob |
| # partition produced by blob.blk. fvm.blk is primarily invoked and used |
| # by the qemu run, via `fx run-fvm`. |
| generate_fvm("fvm.blk") { |
| testonly = true |
| output_name = "$images_dir/fvm.blk" |
| deps = [ |
| ":blob.blk", |
| ] |
| args = fvm_create_args |
| if (fvm_image_size != "") { |
| args += [ |
| "--length", |
| fvm_image_size, |
| ] |
| } |
| args += [ "--blob" ] |
| } |
| fvm_raw_image_path = get_target_outputs(":fvm.blk") |
| image_paths += [ "IMAGE_FVM_RAW=" + rebase_path(fvm_raw_image_path[0], root_build_dir) ] |
| |
| # fvm.sparse.blk creates a sparse FVM partition image containing the blob |
| # partition produced by blob.blk. fvm.sparse.blk is primarily invoked and |
| # used by the paver boot, via `fx boot-paver`. |
| generate_fvm("fvm.sparse.blk") { |
| testonly = true |
| output_name = "$images_dir/fvm.sparse.blk" |
| deps = [ |
| ":blob.blk", |
| ] |
| args = fvm_sparse_args + [ "--blob" ] |
| } |
| fvm_sparse_image_path = get_target_outputs(":fvm.sparse.blk") |
| image_paths += [ "IMAGE_FVM_SPARSE=" + rebase_path(fvm_sparse_image_path[0], root_build_dir) ] |
| |
| # data.blk creates an empty but initialized minfs data partition. |
| # The partition is included in fvm.data.sparse.blk. |
| zircon_tool_action("data.blk") { |
| tool = "minfs" |
| data_image_path = "$target_out_dir/$target_name" |
| outputs = [ |
| data_image_path, |
| ] |
| args = [ |
| rebase_path(data_image_path, root_build_dir) + "@${data_image_size}", |
| "create", |
| ] |
| } |
| data_raw_image_path = get_target_outputs(":data.blk") |
| image_paths += [ "IMAGE_DATA_RAW=" + rebase_path(data_raw_image_path[0], root_build_dir) ] |
| |
| # fmv.data.sparse.blk is an FVM image containing only data.blk. It is |
| # used to pave new data partitions to a device. |
| generate_fvm("fvm.data.sparse.blk") { |
| output_name = "$images_dir/fvm.data.sparse.blk" |
| deps = [ |
| ":data.blk", |
| ] |
| args = fvm_sparse_args + [ "--data" ] |
| } |
| data_fvm_raw_image_path = get_target_outputs(":fvm.data.sparse.blk") |
| image_paths += [ "IMAGE_DATA_FVM_RAW=" + rebase_path(data_fvm_raw_image_path[0], root_build_dir) ] |
| |
| # This packs up Zircon with the command line to enable /system. |
| bootdata("bootdata-blob") { |
| visibility = [ ":*" ] |
| testonly = true |
| deps = [ |
| ":bootdata", |
| ":system_image_cmdline", |
| ] |
| inputs = [] |
| foreach(label, deps) { |
| inputs += get_target_outputs(label) |
| } |
| } |
| bootdata_image_path = get_target_outputs(":bootdata-blob") |
| image_paths += [ "IMAGE_BOOT_RAM=" + rebase_path(bootdata_image_path[0], root_build_dir) ] |
| |
| # This packs up the kernel itself with bootdata-blob (above). This can be |
| # booted directly from a partition by a Zircon-compatible boot loader and |
| # will find blobfs dynamically on storage. |
| bootdata("zircon-boot-blob") { |
| visibility = [ ":*" ] |
| testonly = true |
| inputs = [ |
| "${zircon_build_dir}/zircon.bin", |
| ] |
| deps = [ |
| ":bootdata-blob", |
| ] |
| } |
| zircon_bin_image_path = get_target_outputs(":zircon-boot-blob") |
| image_paths += [ "IMAGE_ZIRCON_ZBI=" + rebase_path(zircon_bin_image_path[0], root_build_dir) ] |
| |
| # This packs (compressed) fvm.blk into BOOTDATA_RAMDISK format, |
| # used by the netboot-* targets below. |
| bootdata_ramdisk("bootdata-fvm") { |
| visibility = [ ":*" ] |
| testonly = true |
| deps = [ |
| ":fvm.blk", |
| ] |
| inputs = [] |
| foreach(label, deps) { |
| inputs += get_target_outputs(label) |
| } |
| } |
| |
| # This packs up a single BOOTDATA container that includes fvm.blk as a |
| # RAMDISK image. This can be used for network booting 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. |
| bootdata("netboot") { |
| testonly = true |
| deps = [ |
| ":bootdata-blob", |
| ":bootdata-fvm", |
| ] |
| inputs = [] |
| foreach(label, deps) { |
| inputs += get_target_outputs(label) |
| } |
| } |
| netboot_ram_image_path = get_target_outputs(":netboot") |
| image_paths += [ "IMAGE_NETBOOT_RAM=" + rebase_path(netboot_ram_image_path[0], root_build_dir) ] |
| |
| # This packs the kernel itself with netboot (above). This can be booted |
| # directly from a partition by a Zircon-compatible boot loader and will |
| # find blobfs directly in the RAMDISK. |
| bootdata("zircon-netboot") { |
| visibility = [ ":*" ] |
| testonly = true |
| inputs = [ |
| "${zircon_build_dir}/zircon.bin", |
| ] |
| deps = [ |
| ":netboot", |
| ] |
| } |
| netboot_zbi_image_path = get_target_outputs(":zircon-netboot") |
| image_paths += [ "IMAGE_NETBOOT_ZBI=" + rebase_path(netboot_zbi_image_path[0], root_build_dir) ] |
| |
| # ChromeOS vboot images. |
| vboot("zircon") { |
| testonly = true |
| deps = [ |
| ":bootdata-blob", |
| ] |
| } |
| zircon_vboot_image_path = get_target_outputs(":zircon.vboot") |
| image_paths += [ "IMAGE_ZIRCON_VBOOT=" + rebase_path(zircon_vboot_image_path[0], root_build_dir) ] |
| |
| if (target_cpu != "arm64") { |
| # EFI ESP images. |
| esp("local") { |
| testonly = true |
| if (always_zedboot) { |
| cmdline = "zedboot/efi_cmdline.txt" |
| } else { |
| cmdline = "efi_local_cmdline.txt" |
| } |
| zircon_bin = "${zircon_build_dir}/zircon.bin" |
| |
| # XXX(raggi): this path is shared with //build/images/BUILD.gn. |
| zedboot_bin = "$root_out_dir/zedboot.bin" |
| |
| bootdatas = get_target_outputs(":bootdata-blob") |
| bootdata_bin = bootdatas[0] |
| |
| deps = [ |
| ":bootdata-blob", |
| "zedboot:zedboot.bin", |
| ] |
| } |
| esp_image_path = get_target_outputs(":local.esp.blk") |
| image_paths += [ "IMAGE_ESP_RAW=" + rebase_path(esp_image_path[0], root_build_dir) ] |
| } |
| |
| # The installer needs all images except for fvm.blk (it has fvm.sparse.blk): |
| installer_images = [ |
| "fvm.sparse.blk", |
| "fvm.data.sparse.blk", |
| "zircon.vboot", |
| ] |
| installer_zedboot_images = [ "zedboot.vboot" ] |
| if (target_cpu != "arm64") { |
| installer_images += [ "local.esp.blk" ] |
| installer_zedboot_images += [ "zedboot.esp.blk" ] |
| } |
| |
| installer_label = "//garnet/bin/installer:install-fuchsia" |
| installer_out_dir = get_label_info(installer_label, "root_out_dir") |
| installer_path = "$installer_out_dir/install-fuchsia" |
| |
| action("installer.manifest") { |
| script = "manifest.py" |
| outputs = [ |
| "$target_out_dir/installer.manifest", |
| ] |
| args = [ |
| "--output=" + rebase_path(outputs[0], root_build_dir), |
| "--output-cwd=" + rebase_path(target_out_dir, root_build_dir), |
| "--entry=install-fuchsia=" + rebase_path(installer_path, root_build_dir), |
| ] |
| foreach(image, installer_images + installer_zedboot_images) { |
| args += [ "--entry=${image}=" + |
| rebase_path("$images_dir/$image", root_build_dir) ] |
| } |
| } |
| |
| # installer.blk is a minfs partition image that includes all of the |
| # images required to install a Fuchsia build. |
| zircon_tool_action("installer") { |
| testonly = true |
| tool = "minfs" |
| deps = [ |
| ":installer.manifest", |
| installer_label, |
| ] |
| outputs = [ |
| "$images_dir/installer.blk", |
| ] |
| sources = [] |
| foreach(image, installer_images) { |
| deps += [ ":$image" ] |
| sources += [ "$images_dir/$image" ] |
| } |
| foreach(image, installer_zedboot_images) { |
| deps += [ "zedboot:$image" ] |
| sources += [ "$images_dir/$image" ] |
| } |
| args = [ |
| rebase_path(outputs[0], root_build_dir), |
| "create", |
| "--manifest", |
| ] |
| args += rebase_path(get_target_outputs(":installer.manifest"), root_build_dir) |
| } |
| installer_image_path = get_target_outputs(":installer") |
| image_paths += [ "IMAGE_INSTALLER_RAW=" + rebase_path(installer_image_path[0], root_build_dir) ] |
| |
| # TODO(mcgrathr): Temporary until scripts and recipes get updated. |
| board = "qemu" |
| if (target_cpu == "x64") { |
| board = "pc" |
| } |
| copy("bootdata-blob-${board}.bin") { |
| testonly = true |
| outputs = [ |
| "$root_out_dir/bootdata-blob-${board}.bin", |
| ] |
| sources = [ |
| "$root_out_dir/bootdata-blob.bin", |
| ] |
| deps = [ |
| ":bootdata-blob", |
| ] |
| } |
| if (target_cpu == "x64") { |
| copy("local-${board}.esp.blk") { |
| testonly = true |
| outputs = [ |
| "$images_dir/local-${board}.esp.blk", |
| ] |
| sources = [ |
| "$images_dir/local.esp.blk", |
| ] |
| deps = [ |
| ":local.esp.blk", |
| ] |
| } |
| copy("zircon-${board}.vboot") { |
| testonly = true |
| outputs = [ |
| "$images_dir/zircon-${board}.vboot", |
| ] |
| sources = [ |
| "$images_dir/zircon.vboot", |
| ] |
| deps = [ |
| ":zircon.vboot", |
| ] |
| } |
| } |
| group("legacy-images") { |
| visibility = [ ":images" ] |
| testonly = true |
| deps = [ |
| ":bootdata-blob-${board}.bin", |
| ] |
| if (target_cpu == "x64") { |
| deps += [ |
| ":local-${board}.esp.blk", |
| ":zircon-${board}.vboot", |
| ] |
| } |
| } |
| |
| group("images") { |
| testonly = true |
| deps = [ |
| ":fvm.blk", |
| ":fvm.data.sparse.blk", |
| ":fvm.sparse.blk", |
| ":ids.txt", |
| ":legacy-images", |
| ":zircon-boot-blob", |
| ":zircon.vboot", |
| "zedboot", |
| ] |
| if (target_cpu != "arm64") { |
| deps += [ ":local.esp.blk" ] |
| } |
| } |
| |
| # See definition of images_paths for purpose. |
| write_file("$root_build_dir/image_paths.sh", image_paths) |
| |
| |
| ### |
| ### Amber updates. |
| ### |
| |
| # update_packages.manifest contains the same entries as the pkgsvr_index but |
| # additionally includes the system_image package. |
| action("update_packages.manifest") { |
| visibility = [ ":update.manifest" ] |
| testonly = true |
| |
| script = "manifest.py" |
| outputs = [ "$target_out_dir/$target_name" ] |
| args = [ |
| "--contents", |
| "--output", |
| rebase_path(outputs[0], root_build_dir), |
| ] |
| deps = [] |
| sources = [] |
| |
| deps += [ ":system_image.meta" ] |
| args += [ "--entry=system_image/0=" + rebase_path("$target_out_dir/system_image.meta/meta.far.merkle", root_build_dir)] |
| |
| foreach(pkg_label, package_targets) { |
| # Find the response file written by package(). |
| pkg_target_name = get_label_info(pkg_label, "name") |
| pkg_target_out_dir = get_label_info(pkg_label, "target_out_dir") |
| pkg_rspfile = "$pkg_target_out_dir/${pkg_target_name}.pkgsvr_index.rsp" |
| deps += [ "${pkg_label}.pkgsvr_index.rsp" ] |
| sources += [ pkg_rspfile ] |
| args += [ "@" + rebase_path(pkg_rspfile, root_build_dir) ] |
| } |
| } |
| |
| # The update package manifest contains the pkgsvr_index and the target system kernel images. |
| action("update.manifest") { |
| visibility = [ ":*" ] |
| testonly = true |
| |
| script = "manifest.py" |
| |
| outputs = [ "$target_out_dir/$target_name" ] |
| |
| args = [ "--output=" + rebase_path(outputs[0], root_build_dir) ] |
| sources = [] |
| deps = [] |
| |
| # Add the meta/package JSON file that makes this the "update" package. |
| json = "update_package.json" |
| sources += [ json ] |
| args += [ "--entry=meta/package=" + rebase_path(json, root_build_dir) ] |
| |
| update_package_manifest_label = ":update_packages.manifest" |
| update_package_manifests = get_target_outputs(update_package_manifest_label) |
| update_package_manifest = update_package_manifests[0] |
| |
| deps += [ update_package_manifest_label ] |
| args += [ "--entry=packages=" + rebase_path(update_package_manifest, root_build_dir) ] |
| |
| # TODO(raggi): reconcile what kernel images should be included, instead of |
| # simply including all of them. |
| |
| if (target_cpu != "arm64") { |
| efi_label = ":local.esp.blk" |
| deps += [ efi_label ] |
| efi_image = get_target_outputs(efi_label) |
| args += [ "--entry=efi=" + rebase_path(efi_image[0], root_build_dir) ] |
| } |
| |
| # TODO(raggi): include ZBI as well here once it is ready. |
| |
| vboot_label = ":zircon.vboot" |
| deps += [ vboot_label ] |
| vboot_image = get_target_outputs(vboot_label) |
| args += [ "--entry=kernc=" + rebase_path(vboot_image[0], root_build_dir) ] |
| } |
| |
| pm_build_package("update.meta") { |
| visibility = [ ":*" ] |
| testonly = true |
| manifest = ":update.manifest" |
| } |
| |
| # XXX(raggi): The following manifests retain the "meta/" files, resulting in |
| # them being added as blobs, which they should not be. A likely better solution |
| # here is to teach pm_build_package to produce either a blob manifest or a |
| # manifest.py --contents compatible response file that excludes these files. |
| |
| action("update.sources.manifest") { |
| visibility = [ ":*" ] |
| testonly = true |
| script = "manifest.py" |
| deps = [ ":update.manifest" ] |
| outputs = [ "$target_out_dir/update.sources.manifest" ] |
| update_manifests = get_target_outputs(deps[0]) |
| args = [ |
| "--sources", |
| "--output=" + rebase_path(outputs[0], root_build_dir), |
| "--manifest=" + rebase_path(update_manifests[0]) |
| ] |
| } |
| |
| zircon_tool_action("update.blobs.manifest") { |
| testonly = true |
| visibility = [ ":amber_publish_blobs" ] |
| tool = "merkleroot" |
| deps = [ |
| ":update.sources.manifest", |
| ] |
| outputs = [ |
| "$target_out_dir/$target_name", |
| ] |
| inputs = get_target_outputs(deps[0]) |
| args = [ |
| "-m", |
| rebase_path(outputs[0]), |
| "@" + rebase_path(inputs[0]), |
| ] |
| } |
| |
| # The amber index is the pkgsvr index, but naming each meta.far file instead of |
| # its merkleroot. Additionally the amber_index has the system package itself, |
| # and the system update package. |
| amber_index = "$target_out_dir/amber_index" |
| |
| action("amber_index") { |
| visibility = [ ":amber_publish_index" ] |
| testonly = true |
| |
| script = "manifest.py" |
| args = [ "--absolute" ] |
| outputs = [ |
| "$target_out_dir/$target_name", |
| ] |
| args += [ "--output=" + rebase_path(outputs[0], root_build_dir) ] |
| sources = [] |
| deps = [] |
| foreach(pkg_label, package_targets) { |
| # Find the response file written by package(). |
| pkg_target_name = get_label_info(pkg_label, "name") |
| pkg_target_out_dir = get_label_info(pkg_label, "target_out_dir") |
| pkg_rspfile = "$pkg_target_out_dir/${pkg_target_name}.amber_index.rsp" |
| deps += [ "${pkg_label}.amber_index.rsp" ] |
| sources += [ pkg_rspfile ] |
| args += [ "@" + rebase_path(pkg_rspfile, root_build_dir) ] |
| } |
| |
| system_image_meta_dir = get_label_info(":system_image.meta", "target_out_dir") + "/system_image.meta" |
| system_image_meta_far = system_image_meta_dir + "/meta.far" |
| args += [ "--entry", "system_image/0=" + rebase_path(system_image_meta_far, root_build_dir) ] |
| deps += [ ":system_image.meta" ] |
| |
| update_meta_dir = get_label_info(":update.meta", "target_out_dir") + "/update.meta" |
| update_meta_far = update_meta_dir + "/meta.far" |
| args += [ "--entry", "update/0=" + rebase_path(update_meta_far, root_build_dir) ] |
| deps += [ ":update.meta" ] |
| } |
| |
| # The blob.manifest that drives blob.blk is just a flat list of files. |
| # blob_merkleroot.manifest is a manifest file of "HEXDIGITS=FILENAME" |
| # lines. Note that this repeats all the same merkleroot computations |
| # that blobfs does while building blob.blk, which is wasteful if the |
| # build is doing both (though the computations can go in parallel and |
| # filesystem caching should mitigate the cost of reading the files |
| # twice). If we're always going to build blob.blk, we could teach |
| # blobfs to emit this manifest on the side rather than recomputing it |
| # here. But if someone tells ninja to build `updates` without `images`, |
| # then this computation alone should be faster than building blob.blk. |
| zircon_tool_action("blob_merkleroot.manifest") { |
| testonly = true |
| visibility = [ ":amber_publish_blobs" ] |
| tool = "merkleroot" |
| deps = [ |
| ":blob.manifest", |
| ] |
| outputs = [ |
| "$target_out_dir/$target_name", |
| ] |
| inputs = [ |
| blob_manifest, |
| ] |
| args = [ |
| "-m", |
| rebase_path(outputs[0]), |
| "@" + rebase_path(blob_manifest), |
| ] |
| } |
| |
| # Populate the repository directory with content ID-named copies. |
| action("amber_publish_blobs") { |
| testonly = true |
| outputs = [ |
| "$amber_repository_dir.stamp", |
| ] |
| deps = [ |
| ":blob_merkleroot.manifest", |
| ":update.blobs.manifest", |
| ] |
| inputs = [] |
| foreach(dep, deps) { |
| inputs += get_target_outputs(dep) |
| } |
| script = "manifest.py" |
| args = [ |
| "--copytree", |
| "--output=" + rebase_path(amber_repository_blobs_dir), |
| "--stamp=" + rebase_path("$amber_repository_dir.stamp"), |
| ] |
| foreach(manifest, inputs) { |
| args += [ "--manifest=" + rebase_path(manifest, root_build_dir) ] |
| } |
| } |
| |
| # Sign and publish the package index. |
| amber_publish("amber_publish_index") { |
| testonly = true |
| deps = [ |
| ":amber_index", |
| ] |
| inputs = [ |
| amber_index, |
| ] |
| } |
| |
| group("updates") { |
| testonly = true |
| deps = [ |
| ":amber_publish_blobs", |
| ":amber_publish_index", |
| ":ids.txt", |
| ] |
| } |
| |
| # SDK |
| |
| sdk_atom("fvm.blk_sdk") { |
| domain = "image" |
| name = "fvm.blk" |
| category = "partner" |
| testonly = true |
| |
| files = [ |
| { |
| source = "$images_dir/fvm.blk" |
| dest = "fvm.blk" |
| } |
| ] |
| |
| non_sdk_deps = [ |
| ":fvm.blk", |
| ] |
| } |
| |
| sdk_atom("bootdata-blob.bin_sdk") { |
| domain = "image" |
| name = "bootdata-blob.bin" |
| category = "partner" |
| testonly = true |
| |
| files = [ |
| { |
| source = "$root_out_dir/bootdata-blob.bin" |
| dest = "bootdata-blob.bin" |
| } |
| ] |
| |
| non_sdk_deps = [ |
| ":bootdata-blob", |
| ] |
| } |
| |
| # TODO(alainv): Add dependency to zircon.bin when such a target exists. |
| sdk_atom("zircon.bin_sdk") { |
| domain = "image" |
| name = "zircon.bin" |
| category = "partner" |
| testonly = true |
| |
| files = [ |
| { |
| source = "${zircon_build_dir}/zircon.bin" |
| dest = "zircon.bin" |
| } |
| ] |
| } |
| |
| sdk_atom("zircon.vboot_sdk") { |
| domain = "image" |
| name = "zircon.vboot" |
| category = "partner" |
| testonly = true |
| |
| files = [ |
| { |
| source = "$images_dir/zircon.vboot" |
| dest = "zircon.vboot" |
| } |
| ] |
| |
| non_sdk_deps = [ |
| ":zircon.vboot", |
| ] |
| } |
| |
| if (target_cpu != "arm64") { |
| sdk_atom("local.esp.blk_sdk") { |
| domain = "image" |
| name = "local.esp.blk" |
| category = "partner" |
| testonly = true |
| |
| files = [ |
| { |
| source = "$images_dir/local.esp.blk" |
| dest = "local.esp.blk" |
| } |
| ] |
| |
| non_sdk_deps = [ |
| ":local.esp.blk", |
| ] |
| } |
| } |
| |
| sdk_atom("fvm.sparse.blk_sdk") { |
| domain = "image" |
| name = "fvm.sparse.blk" |
| category = "partner" |
| testonly = true |
| |
| files = [ |
| { |
| source = "$images_dir/fvm.sparse.blk" |
| dest = "fvm.sparse.blk" |
| } |
| ] |
| |
| non_sdk_deps = [ |
| ":fvm.sparse.blk", |
| ] |
| } |