blob: 17fe6e888319559d6bfb0d932accf152376fffb0 [file] [log] [blame]
# Copyright 2019 The Fuchsia Authors
#
# Use of this source code is governed by a MIT-style
# license that can be found in the LICENSE file or at
# https://opensource.org/licenses/MIT
import("//build/config/zircon/standard.gni")
import("//build/dist/resource.gni")
import("//build/toolchain/zircon/zircon_toolchain_suite.gni")
import("//build/zbi/zbi.gni")
import("//build/zbi/zbi_input.gni")
import("//build/zircon/c_utils.gni")
import("//build/zircon/zircon_cpu.gni")
import("//src/devices/bus/drivers/pci/pci.gni")
import("//zircon/kernel/lib/code-patching/code-patching.gni")
import("//zircon/kernel/phys/kernel_elf_binary.gni")
import("kernel_package.gni")
import("kernel_shell_script.gni")
import("params.gni")
declare_args() {
# Cause //zircon/kernel:boot_tests to generate the phys boot tests
# for all supported CPUs, not just $target_cpu.
all_cpu_kernel_boot_tests = false
# A list of GN labels reaching zbi_input()-style targets to include in the
# kernel ZBI. These targets can be zbi_input(), kernel_cmdline(), etc. to
# inject ZBI items or resource(), etc. to inject items into the filesystem
# image that physboot decodes.
#
# These are injected first, so an item that's itself a zbi_executable() or
# the like can be listed here to be used as a ZBI-to-ZBI boot shim
# (e.g. //zircon/kernel/arch/x86/phys/boot-shim:x86-legacy-zbi-boot-shim)
kernel_zbi_extra_deps = []
# A list of GN labels comprising additional dependencies of the kernel
# proper. This can be useful - in a prototyping or 'vendor' capacity - for
# injecting new instances of subsystems that the kernel has defined modularly
# (e.g., pdev drivers or k commands).
kernel_extra_deps = []
}
if (platform_enable_user_pci) {
disable_kernel_pci = true
}
if (current_toolchain == default_toolchain) {
# In the default toolchain, just define the kernel toolchains.
foreach(cpu, standard_fuchsia_cpus) {
zircon_toolchain_suite("kernel_$cpu") {
cpu = cpu
os = "fuchsia"
environment = "kernel"
if (cpu == "x64") {
kernel_cpu = "x86"
} else {
kernel_cpu = cpu
}
toolchain_tags = [
"kernel",
"standalone",
]
prefix_configs = [
"//zircon/kernel:headers",
# TODO(https://fxbug.dev/42121444): Many include/ headers use <ktl/*.h> headers.
"//zircon/kernel/lib/ktl:headers.config",
"//sdk/lib/fit:headers.config",
"//sdk/lib/stdcompat:headers.config",
# <stdlib.h> has #include <lib/heap.h>.
"//zircon/kernel/lib/heap:headers.config",
# <lib/lockup_detector.h> is included by some "low-level" headers.
"//zircon/kernel/lib/lockup_detector:headers.config",
# <kernel/percpu.h> has #include <lib/lazy_init/lazy_init.h>.
"//zircon/system/ulib/lazy_init:headers.config",
# <kernel/spinlock.h> has #include <lockdep/lock_policy.h>.
"//zircon/system/ulib/lockdep:headers.config",
# <kernel/{scheduler.h,scheduler_state.h> has #include <ffl/fixed.h>.
"//zircon/system/ulib/ffl:headers.config",
# <kernel/thread.h> has #include <vm/kstack.h>.
"//zircon/kernel/vm:headers.config",
# <vm/vm_object.h> has #include <lib/user_copy/user_ptr.h>.
"//zircon/kernel/lib/user_copy:headers.config",
# <lib/ktrace.h> has #include <lib/zircon-internal/ktrace.h>.
"//zircon/system/ulib/zircon-internal:headers.config",
# <lib/ktrace.h> has #include <lib/ktrace/string_ref.h>.
"//zircon/kernel/lib/ktrace:headers.config",
"//zircon/kernel/lib/ktrace:suppress-warning.config",
"//zircon/kernel/lib/special-sections:headers.config",
"//src/performance/lib/fxt:headers.config",
# <kernel/thread.h> has #include <fbl/macros.h>
"//zircon/system/ulib/fbl:headers.config",
# <dev/iommu.h> has #include <fbl/name.h>
"//zircon/kernel/lib/fbl:headers.config",
# <reg.h> has #include <lib/mmio-ptr/mmio-ptr.h>.
"//zircon/system/ulib/mmio-ptr:headers.config",
# Everywhere has #include <lib/fit/result.h>
# Everywhere has #include <zx/result.h>
"//zircon/system/ulib/zx:headers.config",
"//zircon/kernel/lib/backtrace:headers.config",
"//zircon/kernel/lib/version:headers.config",
# <platform.h> has #include <lib/arch/ticks.h>.
"//zircon/kernel/lib/arch/$kernel_cpu:headers.config",
"//zircon/kernel/lib/arch:common-headers.config",
# Many headers have #include <lib/zbi-format/zbi.h>.
"//sdk/lib/zbi-format:include",
]
configs = [ "//zircon/kernel:kernel_config" ]
# NOTE: kernel artifacts currently do not build under fuzzer
# variants. This was also true with the Zircon build, but
# the Fuchsia build never invoked it with corresponding
# variant selectors. Using an exclude_variant_tag is
# enough to fix the issue.
exclude_variant_tags = [ "fuzzer" ]
if (cpu == "riscv64") {
# TODO(https://fxbug.dev/42076027): no asan for riscv64 yet
exclude_variant_tags += [ "asan" ]
}
# Always enable frame pointers in the kernel so there are panic
# backtraces and such.
# TODO(mcgrathr): Consider either removing this so there's a
# no-frame-pointers option, or removing the kernel's support for
# !WITH_FRAME_POINTERS if it will never be used.
remove_common_configs = [ "//build/config:default_frame_pointers" ]
configs += [ "//build/config:frame_pointers" ]
if (cpu == "x64") {
# TODO(https://fxbug.dev/42101838): x86 kernel can't be built without --gc-sections
# because of crufty acpica code, and some compiler instrumentation
# is broken wrt --gc-sections semantics.
# Ensure that linker GC is enabled.
configs += [ "//build/config:linker_gc" ]
}
# As a special case, kernel assertions are controlled by the kernel_debug_level
# variable, and not zx_assert_level (though it defaults to the same value, but
# some product configurations may decide to change it).
remove_common_configs += [ "//build/config/zircon:default_assert_level" ]
# Map kernel_debug_level above 2 to an assert_level of 2, as that is the
# highest valid assertion level.
if (kernel_debug_level > 2) {
kernel_assert_level = 2
} else {
kernel_assert_level = kernel_debug_level
}
configs += [ "//build/config/zircon:assert_level_$kernel_assert_level" ]
# TODO(https://fxbug.dev/42150661): the kernel crashes on boot if built with -O0.
_optimize_none = [ "//build/config:optimize_none" ]
if (configs + _optimize_none - _optimize_none != configs) {
configs -= _optimize_none
configs += [ "//build/config:optimize_debug" ]
}
}
}
}
# For any standalone static binary.
config("standalone") {
ldflags = [
"-nostdlib",
"-static",
]
cflags = [
"-ffreestanding",
"-include",
rebase_path("include/hidden.h", root_build_dir),
# We want `.debug_frame` for the kernel (https://fxbug.dev/42104841). And we still want
# asynchronous unwind tables. Alas there's (currently) no way to
# achieve this with our GCC. At the moment we compile with
# `-fno-omit-frame-pointer`, which is good because we link with
# `--gc-sections`, which means `.eh_frame` gets discarded so GCC-built
# kernels don't have any unwind info (except for assembly)!
"-fno-unwind-tables",
]
# Always feed assembler code the `.cfi_sections` directive to
# populate only `.debug_frame` and not `.eh_frame`.
asmflags = [
"-include",
rebase_path("debug-frame.S", root_build_dir),
]
cflags_cc = [
# Underlying kernel heap only has default alignment of 8 bytes, so pass
# this to the compiler as the default new alignment.
"-faligned-new=8",
]
if (current_os != "win") {
if (current_cpu == "x64") {
# This only matters in an environment where interrupt handlers might
# push trap frames in the same privilege level, like the kernel.
# e.g. Multiboot probably doesn't actually need it, but it doesn't hurt.
cflags += [ "-mno-red-zone" ]
} else if (current_cpu == "arm64") {
# This matters if vector registers are not available, e.g. in the kernel
# since the they hold unsaved user state, or in the physmem environment
# because they might not be enabled in hardware yet.
cflags += [ "-mgeneral-regs-only" ]
}
}
if (is_gcc && current_os == "fuchsia") {
cflags += [ "-fpie" ]
}
if (!is_gcc && current_os == "fuchsia") {
# In the Fuchsia-target toolchains there's no way to prevent the
# compiler driver from passing -pie, so negate it. BFD ld doesn't
# have --no-pie, but arm64-elf-gcc doesn't pass -pie either.
ldflags += [ "-Wl,--no-pie" ]
}
configs = [ "//build/config:no_exceptions" ]
}
if (is_kernel) {
# These are needed both in kernel sources (pervasively) and in the linker
# scripts.
kernel_defines = [
# TODO: should not be needed in C, but is in one place now.
"KERNEL_BASE=$kernel_base",
"SMP_MAX_CPUS=$smp_max_cpus",
]
# This is the top config for all kernel code.
config("kernel_config") {
configs = [
":jtrace_config",
":lock_dep",
":scheduler",
":virtual_heap",
":standalone",
":warnings",
"arch/$zircon_cpu:abi",
"arch/$zircon_cpu:kernel",
"//build/config:no-finite-loops",
"//build/config:zero-call-used-regs",
# include/lib/counters.h and kernel.ld depend on -fdata-sections.
"//build/config/zircon:data_sections",
]
# TODO(https://fxbug.dev/42101573): This dependency is conditional because when built
# with GCC the kernel uses function scoped statics requiring dynamic
# initialization. Once https://fxbug.dev/42101573 is fixed, this dependency can be
# removed.
if (is_gcc) {
# Don't emit extra code making static initializers thread-safe.
configs += [ "//build/config/zircon:no_threadsafe_statics" ]
}
# Always enable frame pointers in the kernel so there are panic
# backtraces and such.
# TODO(mcgrathr): Consider either removing this so there's a
# no-frame-pointers option, or removing the kernel's support for
# !WITH_FRAME_POINTERS if it will never be used.
configs += [ "//build/config:frame_pointers" ]
defines = kernel_defines + kernel_extra_defines
defines += [
"_KERNEL",
"LK",
"ENABLE_PANIC_SHELL",
"ZIRCON_TOOLCHAIN",
"LK_DEBUGLEVEL=$kernel_debug_level",
"DEBUG_PRINT_LEVEL=$kernel_debug_print_level",
"VM_TRACING_LEVEL=$vm_tracing_level",
"FUTEX_TRACING_ENABLED=$futex_tracing_enabled",
"FUTEX_BLOCK_TRACING_ENABLED=$futex_block_tracing_enabled",
"LOCK_TRACING_ENABLED=$lock_tracing_enabled",
"EXPERIMENTAL_THREAD_SAMPLER_ENABLED=$experimental_thread_sampler_enabled",
]
if (!disable_kernel_pci) {
defines += [ "WITH_KERNEL_PCIE" ]
}
if (kernel_no_userabi) {
defines += [ "KERNEL_NO_USERABI" ]
}
cflags = [ "-fpie" ]
}
group("kernel_config_deps") {
}
config("headers") {
include_dirs = [
"include",
"lib/libc/include",
]
# This is in public_configs of libc:headers, so we need it explicitly here
# to match up with the include_dirs here that replicates what a proper dep
# on libc:headers would yield.
configs = [ "lib/libc:headers.after" ]
}
config("warnings") {
cflags = [
"-Wformat=2",
"-Wmissing-declarations",
"-Wvla",
]
# GCC supports `-Wformat-signedness` but Clang currently does not.
if (is_gcc) {
cflags += [ "-Wformat-signedness" ]
}
# TODO(https://fxbug.dev/42159114): Eventually enable -Wshadow for GCC. It's currently
# disabled because GCC is more aggressive than Clang.
if (!is_gcc) {
cflags += [ "-Wshadow" ]
}
cflags_c = [ "-Wmissing-prototypes" ]
}
config("lock_dep") {
visibility = [ ":*" ]
defines = []
if (enable_lock_dep) {
defines += [
"WITH_LOCK_DEP=1",
"LOCK_DEP_ENABLED_FEATURE_LEVEL=2",
]
configs =
[ "//build/config/zircon/instrumentation:instrumented-stack-size" ]
} else if (enable_lock_dep_metadata_only ||
scheduler_lock_spin_tracing_enabled) {
defines += [
"WITH_LOCK_DEP=1",
"LOCK_DEP_ENABLED_FEATURE_LEVEL=1",
]
configs =
[ "//build/config/zircon/instrumentation:instrumented-stack-size" ]
}
if (enable_lock_dep_tests) {
defines += [ "WITH_LOCK_DEP_TESTS=1" ]
}
}
config("scheduler") {
visibility = [ ":*" ]
defines = [
"SCHEDULER_TRACING_LEVEL=$scheduler_tracing_level",
"SCHEDULER_QUEUE_TRACING_ENABLED=$scheduler_queue_tracing_enabled",
"SCHEDULER_EXTRA_INVARIANT_VALIDATION=$scheduler_extra_invariant_validation",
"SCHEDULER_LOCK_SPIN_TRACING_COMPRESSED=$scheduler_lock_spin_tracing_compressed",
"SCHEDULER_LOCK_SPIN_TRACING_ENABLED=$scheduler_lock_spin_tracing_enabled",
"WAIT_QUEUE_DEPTH_TRACING_ENABLED=$wait_queue_depth_tracing_enabled",
]
}
config("virtual_heap") {
visibility = [ ":*" ]
defines = []
if (enable_virtual_heap) {
defines += [ "VIRTUAL_HEAP=1" ]
} else {
defines += [ "VIRTUAL_HEAP=0" ]
}
}
config("persistent_ram_config") {
visibility = [
":*",
"//zircon/kernel/lib/crashlog/*",
"//zircon/kernel/lib/jtrace/*",
"//zircon/kernel/lib/persistent-debuglog/*",
]
defines = [ "PERSISTENT_RAM_ALLOCATION_GRANULARITY=$persistent_ram_allocation_granularity" ]
}
config("jtrace_config") {
visibility = [
":*",
"//zircon/kernel/lib/jtrace/*",
]
if (!jtrace_enabled) {
defines = [ "JTRACE_TARGET_BUFFER_SIZE=0" ]
} else {
if (jtrace_target_buffer_size == "auto") {
if (jtrace_enabled == "persistent") {
jtrace_target_buffer_size = 4096
} else {
jtrace_target_buffer_size = 32768
}
}
if (jtrace_use_large_entries == "auto") {
if (jtrace_enabled == "persistent") {
jtrace_use_large_entries = false
} else {
jtrace_use_large_entries = true
}
}
defines = [
"JTRACE_TARGET_BUFFER_SIZE=$jtrace_target_buffer_size",
"JTRACE_LAST_ENTRY_STORAGE=$jtrace_last_entry_storage",
"JTRACE_USE_LARGE_ENTRIES=$jtrace_use_large_entries",
]
if (jtrace_enabled == "persistent") {
defines += [ "JTRACE_IS_PERSISTENT=true" ]
} else {
defines += [ "JTRACE_IS_PERSISTENT=false" ]
}
}
}
# This is the kernel proper, an ELF executable with full symbols.
# It's the file to use with a debugger, for example.
executable("zircon.elf") {
visibility = [ ":*" ]
# //zircon/scripts/zircon.elf-gdb.py expects kernel symbols in "zircon.elf".
output_name = "zircon"
output_extension = "elf"
ldflags = [
"-Wl,-T," + rebase_path("kernel.ld", root_build_dir),
"-Wl,--emit-relocs",
]
if (toolchain_variant.tags + [ "lto" ] - [ "lto" ] !=
toolchain_variant.tags) {
# (Thin)LTO linker driver overrides the PIC/PIE metadata embedded in the
# IR and will choose the relocation model based on the output which for
# the kernel would be static rather than PIE. We need to explicitly
# override the relocation via linker flag.
ldflags += [ "-Wl,-mllvm,-relocation-model=pic" ]
}
inputs = [ "kernel.ld" ]
configs += [ ":kernel_defsym" ]
deps = [
":zircon-main",
"arch/$zircon_cpu:zbi-kernel-image",
]
}
kernel_elf_binary("physzircon") {
visibility = [ ":*" ]
configs += [
":elf-kernel.config",
":kernel_defsym",
]
deps = [
":zircon-main",
"phys:physboot.kernel",
]
}
config("elf-kernel.config") {
visibility = [ ":*" ]
inputs = [ "elf-kernel.ld" ]
ldflags = [ "-Wl,-T," + rebase_path(inputs[0], root_build_dir) ]
configs = [
"//build/config/zircon:static-pie-compile",
"//build/config/zircon:static-pie-link",
]
}
group("zircon-main") {
deps = [
":test", # TODO: make optional, add testonly taint
"top",
# Ensures that //docs/gen/boot-options.md is never stale.
"lib/boot-options:check-markdown($default_toolchain)",
] + kernel_extra_deps
if (current_cpu == "arm64") {
deps += [ "platform/generic-arm" ]
} else if (current_cpu == "riscv64") {
deps += [ "platform/generic-riscv64" ]
} else if (current_cpu == "x64") {
deps += [ "target/pc" ]
}
}
zircon_elf_rspfile = "$target_gen_dir/zircon.elf.rsp"
link_output_rspfile("zircon.elf.rsp") {
visibility = [ ":*" ]
deps = [ ":zircon.elf" ]
outputs = [ zircon_elf_rspfile ]
}
# These are needed only in image.S and in the linker scripts.
image_defines = [ "BOOT_HEADER_SIZE=0x50" ]
# This supplies those variables for use in linker scripts.
config("kernel_defsym") {
visibility = [ ":*" ]
ldflags = []
foreach(assignment, kernel_defines + image_defines) {
ldflags += [ "-Wl,-defsym,$assignment" ]
}
}
group("test") {
#TODO: testonly = true
visibility = [ ":*" ]
deps = [
"debugcommands",
"tests",
]
}
# Extract the raw binary image (no ELF headers) of the kernel proper.
image_binary("raw") {
visibility = [ ":*" ]
deps = [ ":zircon.elf" ]
output_name = "zircon"
output_path =
rebase_path("$target_out_dir/$output_name.bin", root_build_dir)
metadata = {
# Picked up by link_output_rspfile(), below.
link_output_path = [ output_path ]
link_output_barrier = []
}
}
image_rspfile = "$target_gen_dir/image.rsp"
link_output_rspfile("image.rsp") {
visibility = [ ":*" ]
outputs = [ image_rspfile ]
deps = [ ":raw" ]
}
action("kernel-image.h") {
visibility = [ ":*" ]
outputs = [ "$target_gen_dir/$target_name" ]
script = "gen-kernel-image-header.sh"
deps = [ ":image.rsp" ]
sources = [ image_rspfile ]
depfile = "$target_gen_dir/$target_name.d"
args = rebase_path(sources + outputs + [ depfile ], root_build_dir)
}
# Use the --emit-relocs records to extract the fixups needed to relocate
# the kernel at boot. This generates the "kernel-fixups.inc" file that's
# #include'd by "arch/$zircon_cpu/image.S".
toolchain_utils_action("fixups") {
visibility = [ ":*" ]
deps = [
":zircon.elf",
":zircon.elf.rsp",
]
sources = [ zircon_elf_rspfile ]
outputs = [ "$target_gen_dir/kernel-fixups.inc" ]
depfile = "${outputs[0]}.d"
script = "gen-kaslr-fixups.sh"
utils = [
"readelf",
"objdump",
]
args = [
"@" + rebase_path(zircon_elf_rspfile, root_build_dir),
rebase_path(outputs[0], root_build_dir),
rebase_path(depfile, root_build_dir),
]
}
toolchain_utils_action("validate-kernel-symbols") {
visibility = [ ":*" ]
outputs = [ "$target_gen_dir/$target_name.stamp" ]
script = "//zircon/kernel/scripts/validate-kernel-symbols.py"
utils = [ "nm" ]
deps = [
":zircon.elf",
":zircon.elf.rsp",
]
sources = [ zircon_elf_rspfile ]
depfile = "$target_gen_dir/$target_name.d"
args = rebase_path(sources + outputs + [ depfile ], root_build_dir)
}
# Link the final kernel image layout including the extracted raw binary
# and the generated fixups.
executable("image") {
visibility = [ ":*" ]
configs += [
":image_config",
":kernel_defsym",
]
deps = [
":fixups",
":gdb_extension",
":kernel-image.h",
":raw",
":zircon.elf",
":zircon.elf.rsp",
"//zircon/kernel/lib/arch:headers",
]
# TODO(https://fxbug.dev/42101573): This dependency is conditional because when built
# with GCC BootCpuidIo uses a function scoped static requiring dynamic
# initialization, which won't pass symbol validation. Once https://fxbug.dev/42101573
# is fixed, the dynamic initialization can be removed and this dependency
# can be made unconditional.
if (!is_gcc) {
deps += [ ":validate-kernel-symbols" ]
}
sources = [ "arch/$zircon_cpu/image.S" ]
include_dirs = [ "." ] # For kernel-image.inc.
# These need to be here rather than in the config() below because they
# refer directly to inputs related to deps.
ldflags = [
"-Wl,-T," + rebase_path("image.ld", root_build_dir),
"-Wl,--just-symbols,@" + rebase_path(zircon_elf_rspfile, root_build_dir),
]
inputs = [
"image.ld",
zircon_elf_rspfile,
]
# If the span of where fixups might be is short enough, the fixup code
# itself can be shorter. Assume the kernel will fit under the
# threshold (about 1MB) in well-optimized builds.
if (optimize != "none" && optimize != "debug" &&
toolchain_variant.tags + [ "instrumented" ] - [ "instrumented" ] ==
toolchain_variant.tags) {
defines = [ "TINY" ]
}
}
# Copy gdb extension script file needed for kernel debugging.
copy("gdb_extension") {
visibility = [ ":*" ]
sources = [ "scripts/zircon.elf-gdb.py" ]
outputs = [ "$root_out_dir/zircon.elf-gdb.py" ]
}
# This needs to be in a config() rather than directly in the executable()
# so that these switches come after the ones provided by configs. In
# some cases, these switches may be overriding settings done by another
# config(), e.g. --build-id in the GCC build.
config("image_config") {
visibility = [ ":*" ]
include_dirs = [ target_gen_dir ]
defines = image_defines
ldflags = [ "-Wl,--build-id=none" ]
}
# Next, extract the raw image (no ELF headers), which includes its own
# embedded headers to make it a ZBI.
image_binary("zbizircon") {
visibility = [ ":*" ]
deps = [ ":image" ]
output_extension = "zbi"
metadata = {
# See zbizircon.rsp, below.
zbi_kernel_file =
[ rebase_path("$target_out_dir/$target_name.$output_extension",
root_build_dir) ]
}
}
# Then that gets compressed to become part of the ZBI_TYPE_KERNEL_STORAGE
# payload.
resource("zbizircon.input") {
sources = get_target_outputs(":zbizircon")
outputs = [ "kernel.zbi" ]
deps = [ ":zbizircon" ]
}
code_patches("code-patches") {
deps = [ ":zircon.elf" ]
# This reaches the files generated by code_patching_hermetic_alternative().
# code_patches() blocks metadata traversals from finding files in its deps,
# but not its data_deps.
data_deps = [ ":zircon-main" ]
}
kernel_package("zircon") {
if (use_elf_kernel) {
assert(current_cpu != "x64", "use_elf_kernel=true not supported on x86")
deps = [ ":physzircon" ]
} else {
deps = [
":code-patches",
":zbizircon.input",
]
}
# Embed the version-string.txt file directly in the package subdirectory.
deps += [ "//zircon/kernel/lib/version:version-string.txt" ]
}
# The final kernel ZBI combines physboot with that kernel storage payload.
zbi("kernel") {
deps = kernel_zbi_extra_deps
deps += [
":zircon",
"phys:physboot",
]
compress = "zstd.max"
output_dir = root_out_dir
output_extension = "zbi"
output_path = rebase_path("$output_dir/$target_name.$output_extension",
root_build_dir)
metadata = {
# For the //:images build_api_module().
images = [
{
label = get_label_info(":$target_name", "label_with_toolchain")
name = "kernel"
tags = [ "incomplete" ]
type = "zbi"
path = output_path
cpu = current_cpu
},
]
}
}
} else {
group("kernel") {
public_deps = [ ":kernel(//zircon/kernel:kernel_$target_cpu)" ]
}
group("tests") {
testonly = true
deps = [
"arch/$zircon_cpu/user-copy:tests",
"dev/coresight/tests($host_toolchain)",
"lib/acpi_lite:tests",
"lib/arch:tests",
"lib/boot-options/tests",
"lib/devicetree/tests",
"lib/efi:tests",
"lib/heap/cmpctmalloc:tests",
"lib/sched:tests",
"phys:tests",
"phys/lib:tests",
"target:tests",
]
if (current_cpu == "x64") {
deps += [ "lib/libc/string/arch/x86:tests" ]
}
# TODO(https://fxbug.dev/42101573): This dependency is conditional because when built
# with GCC the kernel uses function scoped statics requiring dynamic
# initialization. Once https://fxbug.dev/42101573 is fixed, this dependency can be made
# unconditional.
if (!is_gcc) {
deps += [ "lib/cxxabi-dynamic-init/tests" ]
}
# Don't let any test ZBIs roll up into the overall product image.
metadata = {
zbi_input_barrier = []
}
}
# TODO(https://fxbug.dev/42080558): The x86 kernel gets loaded at a fixed physical
# address of 1MiB. The UEFI environment under QEMU has some memory reserved
# at about 8MiB. This limits the total kernel image size that can be loaded.
# A larger kernel image size will get a panic in early boot (physboot).
# Until the kernel's internal fixed-location constraint is removed, kernel
# images that are too big just can't be loaded. Some instrumented kernels
# like asan/ubsan builds can wind up too big. So this collects the file name
# of the internal kernel image and feeds that into a script that examines
# the image to determine the memory size it will require.
generated_file("zbizircon.rsp") {
visibility = [ ":*" ]
testonly = true
outputs = [ "$target_gen_dir/$target_name" ]
output_conversion = "list lines"
data_keys = [ "zbi_kernel_file" ]
deps = [ ":kernel" ]
}
action("big-kernel.rsp") {
visibility = [ ":*" ]
testonly = true
script = "big-kernel.py"
outputs = [ "$target_gen_dir/$target_name" ]
depfile = "${outputs[0]}.d"
deps = [ ":zbizircon.rsp" ]
sources = get_target_outputs(deps[0])
assert(sources == [ sources[0] ])
args = [
"--depfile=" + rebase_path(depfile, root_build_dir),
"--rust-cfg-rspfile=" + rebase_path(outputs[0], root_build_dir),
rebase_path(sources[0], root_build_dir),
]
}
group("rust-cfg-big-zircon-kernel") {
testonly = true
public_deps = [ ":big-kernel.rsp" ]
public_configs = [ ":rust-big-kernel.config" ]
}
config("rust-big-kernel.config") {
visibility = [ ":*" ]
inputs = get_target_outputs(":big-kernel.rsp")
assert(inputs == [ inputs[0] ])
rustflags = [ "@" + rebase_path(inputs[0], root_build_dir) ]
}
}
if (!is_efi_toolchain) {
group("boot_tests") {
testonly = true
deps = [
":kernel-unittests-boot-test",
"phys:boot_tests",
"//zircon/kernel/lib/userabi/userboot/tests:boot_tests",
]
if (all_cpu_kernel_boot_tests) {
foreach(cpu, standard_fuchsia_cpus) {
deps += [ ":boot_tests.$cpu" ]
}
}
}
kernel_shell_script_test("kernel-unittests-boot-test") {
device_types = kernel_test_device_types
script = [
"ut all",
"and ut -r 10 timer",
"and ut -r 10 pi",
"boot-test-success",
"graceful-shutdown",
]
}
}
foreach(cpu, standard_fuchsia_cpus) {
group("boot_tests.$cpu") {
testonly = true
deps = [
":kernel-unittests-boot-test(:kernel_$cpu)",
"phys/test:$cpu",
]
}
}