From 8503690aa21e368356af28ed21ea5132c6bc92b4 Mon Sep 17 00:00:00 2001 From: John Moon Date: Mon, 24 Oct 2022 18:04:53 -0700 Subject: [PATCH] build: Add support for Bazel VM builds Currently, only legacy build.sh support exists for VM builds. Add Bazel support for these builds. Change-Id: I10b221aa4a6633240b984eff333e15f5cd8b82cd Signed-off-by: John Moon --- build_with_bazel.py | 2 + image_opts.bzl | 31 ++++ kalama.bzl | 12 +- kalama_tuivm.bzl | 11 ++ msm_abl.bzl | 21 +++ msm_common.bzl | 34 ++++ msm_dtc.bzl | 59 +++++++ msm_kernel_extensions.bzl | 2 +- msm_kernel.bzl => msm_kernel_la.bzl | 201 +++++++--------------- msm_kernel_vm.bzl | 258 ++++++++++++++++++++++++++++ msm_platforms.bzl | 4 + pineapple.bzl | 11 +- pineapple_tuivm.bzl | 11 ++ target_variants.bzl | 23 ++- 14 files changed, 523 insertions(+), 157 deletions(-) create mode 100644 image_opts.bzl create mode 100644 kalama_tuivm.bzl create mode 100644 msm_abl.bzl create mode 100644 msm_common.bzl create mode 100644 msm_dtc.bzl rename msm_kernel.bzl => msm_kernel_la.bzl (72%) create mode 100644 msm_kernel_vm.bzl create mode 100644 pineapple_tuivm.bzl diff --git a/build_with_bazel.py b/build_with_bazel.py index 0855167752aa..ed212f0e54a4 100755 --- a/build_with_bazel.py +++ b/build_with_bazel.py @@ -81,6 +81,8 @@ def build( "skipping host tools build" ) if skip_host_tools else host_targets_to_build.append(t + "_dtc") + targets_to_build.append(t + "_test_mapping") + targets_to_build += extra_msm_targets if not targets_to_build: diff --git a/image_opts.bzl b/image_opts.bzl new file mode 100644 index 000000000000..468411b32f0a --- /dev/null +++ b/image_opts.bzl @@ -0,0 +1,31 @@ +def boot_image_opts( + boot_image_header_version = 4, + base_address = 0x80000000, + page_size = 4096, + super_image_size = 0x10000000, + lz4_ramdisk = True): + return struct( + boot_image_header_version = boot_image_header_version, + base_address = base_address, + page_size = page_size, + super_image_size = super_image_size, + lz4_ramdisk = lz4_ramdisk, + ) + +def vm_image_opts( + preferred_usespace = "vm", + vm_dtb_img_create = True, + kernel_offset = 0x0, + dtb_offset = 0x2000000, + ramdisk_offset = 0x2100000, + vm_size_ext4 = 270000000, + dummy_img_size = 4096): + return struct( + preferred_usespace = preferred_usespace, + vm_dtb_img_create = vm_dtb_img_create, + kernel_offset = kernel_offset, + dtb_offset = dtb_offset, + ramdisk_offset = ramdisk_offset, + vm_size_ext4 = vm_size_ext4, + dummy_img_size = dummy_img_size, + ) diff --git a/kalama.bzl b/kalama.bzl index b5459e85ba56..bc6c8d4b0b40 100644 --- a/kalama.bzl +++ b/kalama.bzl @@ -1,5 +1,5 @@ -load(":target_variants.bzl", "targets", "variants") -load(":msm_kernel.bzl", "define_msm") +load(":target_variants.bzl", "la_variants") +load(":msm_kernel_la.bzl", "define_msm_la") target_name = "kalama" @@ -91,6 +91,7 @@ def define_kalama(): ] _kalama_consolidate_in_tree_modules = _kalama_in_tree_modules + [ + # keep sorted ] # Modules built but not copied to dist directory @@ -100,16 +101,13 @@ def define_kalama(): "mm/zsmalloc.ko", ] - if not target_name in targets: - fail("{} not defined in target_variants.bzl".format(target_name)) - - for variant in variants: + for variant in la_variants: if variant == "consolidate": mod_list = _kalama_consolidate_in_tree_modules else: mod_list = _kalama_in_tree_modules - define_msm( + define_msm_la( msm_target = target_name, variant = variant, in_tree_module_list = mod_list, diff --git a/kalama_tuivm.bzl b/kalama_tuivm.bzl new file mode 100644 index 000000000000..009431df630b --- /dev/null +++ b/kalama_tuivm.bzl @@ -0,0 +1,11 @@ +load(":target_variants.bzl", "vm_variants") +load(":msm_kernel_vm.bzl", "define_msm_vm") + +target_name = "kalama-tuivm" + +def define_kalama_tuivm(): + for variant in vm_variants: + define_msm_vm( + msm_target = target_name, + variant = variant, + ) diff --git a/msm_abl.bzl b/msm_abl.bzl new file mode 100644 index 000000000000..7ce3603518d8 --- /dev/null +++ b/msm_abl.bzl @@ -0,0 +1,21 @@ +load("//build/bazel_common_rules/dist:dist.bzl", "copy_to_dist_dir") + +def define_abl_dist(target): + """Creates ABL distribution target + + Args: + target: name of main Bazel target (e.g. `kalama_gki`) + """ + native.alias( + name = "{}_abl".format(target), + actual = "//bootable/bootloader/edk2:{}_abl".format(target), + ) + + copy_to_dist_dir( + name = "{}_abl_dist".format(target), + archives = ["{}_abl".format(target)], + dist_dir = "out/msm-kernel-{}/dist".format(target.replace("_", "-")), + flat = True, + wipe_dist_dir = False, + log = "info", + ) diff --git a/msm_common.bzl b/msm_common.bzl new file mode 100644 index 000000000000..14fa6594e248 --- /dev/null +++ b/msm_common.bzl @@ -0,0 +1,34 @@ +def define_top_level_config(target): + """Define common top-level variables in build.config""" + rule_name = "{}_top_level_config".format(target) + native.genrule( + name = rule_name, + srcs = [], + outs = ["build.config.bazel.top.level.{}".format(target)], + cmd_bash = """ + cat << 'EOF' > "$@" +# === define_top_level_config === +BUILDING_WITH_BAZEL=true +# === end define_top_level_config === +EOF + """, + ) + + return ":{}".format(rule_name) + +def gen_config_without_source_lines(build_config, target): + """Replace "." or "source" lines in build.config files with shell null operator""" + rule_name = "{}.{}".format(target, build_config) + out_file_name = rule_name + ".generated" + native.genrule( + name = rule_name, + srcs = [build_config], + outs = [out_file_name], + cmd_bash = """ + sed -e 's/^ *\\. /: # &/' \ + -e 's/^ *source /: # &/' \ + $(location {}) > "$@" + """.format(build_config), + ) + + return ":" + rule_name diff --git a/msm_dtc.bzl b/msm_dtc.bzl new file mode 100644 index 000000000000..09f3687bfd66 --- /dev/null +++ b/msm_dtc.bzl @@ -0,0 +1,59 @@ +load("//build/bazel_common_rules/dist:dist.bzl", "copy_to_dist_dir") + +def define_dtc_dist(target): + """Create distribution targets for device tree compiler and associated tools + + Args: + target: name of main Bazel target (e.g. `kalama_gki`) + """ + dtc_bin_targets = [ + "@dtc//:dtc", + "@dtc//:fdtget", + "@dtc//:fdtput", + "@dtc//:fdtdump", + "@dtc//:fdtoverlay", + "@dtc//:fdtoverlaymerge", + ] + dtc_lib_targets = [ + "@dtc//:dtc_gen", + "@dtc//:libfdt", + ] + dtc_inc_targets = [ + "@dtc//:libfdt/fdt.h", + "@dtc//:libfdt/libfdt.h", + "@dtc//:libfdt/libfdt_env.h", + ] + + dtc_tar_cmd = "mkdir -p bin lib include\n" + for label in dtc_bin_targets: + dtc_tar_cmd += "cp $(locations {}) bin/\n".format(label) + for label in dtc_lib_targets: + dtc_tar_cmd += "cp $(locations {}) lib/\n".format(label) + for label in dtc_inc_targets: + dtc_tar_cmd += "cp $(locations {}) include/\n".format(label) + dtc_tar_cmd += """ + chmod 755 bin/* lib/* + chmod 644 include/* + tar -czf "$@" bin lib include + """ + + native.genrule( + name = "{}_dtc_tarball".format(target), + srcs = dtc_bin_targets + dtc_lib_targets + dtc_inc_targets, + outs = ["{}_dtc.tar.gz".format(target)], + cmd = dtc_tar_cmd, + ) + + native.alias( + name = "{}_dtc".format(target), + actual = ":{}_dtc_tarball".format(target), + ) + + copy_to_dist_dir( + name = "{}_dtc_dist".format(target), + archives = [":{}_dtc_tarball".format(target)], + dist_dir = "out/msm-kernel-{}/host".format(target.replace("_", "-")), + flat = True, + wipe_dist_dir = True, + log = "info", + ) diff --git a/msm_kernel_extensions.bzl b/msm_kernel_extensions.bzl index 47fc57527b9e..c124f0c735a7 100644 --- a/msm_kernel_extensions.bzl +++ b/msm_kernel_extensions.bzl @@ -1,4 +1,4 @@ -def define_extras(target): +def define_extras(target, flavor = None): return def get_build_config_fragments(target): diff --git a/msm_kernel.bzl b/msm_kernel_la.bzl similarity index 72% rename from msm_kernel.bzl rename to msm_kernel_la.bzl index c1d3873bc214..1fd622454990 100644 --- a/msm_kernel.bzl +++ b/msm_kernel_la.bzl @@ -1,4 +1,5 @@ load("//build/bazel_common_rules/dist:dist.bzl", "copy_to_dist_dir") +load("//build/bazel_common_rules/test_mappings:test_mappings.bzl", "test_mappings_dist") load( "//build/kernel/kleaf:kernel.bzl", "kernel_build_abi", @@ -18,17 +19,18 @@ load( "get_dtstree", "get_vendor_ramdisk_binaries", ) +load(":msm_common.bzl", "define_top_level_config", "gen_config_without_source_lines") +load(":msm_dtc.bzl", "define_dtc_dist") +load(":msm_abl.bzl", "define_abl_dist") load(":super_image.bzl", "super_image") +load(":image_opts.bzl", "boot_image_opts") +load(":target_variants.bzl", "la_variants") -def define_build_config( +def _define_build_config( msm_target, target, variant, - boot_image_header_version, - base_address, - page_size, - super_image_size, - lz4_ramdisk, + boot_image_opts = boot_image_opts(), build_config_fragments = []): """Creates a kernel_build_config for an MSM target @@ -39,35 +41,10 @@ def define_build_config( variant: variant of kernel to build (e.g. "gki") """ - # Top-level variables set in build.config - native.genrule( - name = "{}_top_level_config".format(target), - srcs = [], - outs = ["build.config.bazel.top.level.{}".format(target)], - cmd_bash = """ - { - echo BUILDING_WITH_BAZEL=true - } > "$@" - """ - ) - - # Remove sourcing lines from build config since we're just concatenating fragments below - native.genrule( - name = "{}_build_config_common_without_source".format(target), - srcs = ["build.config.common"], - outs = ["{}_build.config.common.generated".format(target)], - cmd_bash = "sed -e '/^\\. /d' $(location build.config.common) > $@", - ) - - # Generate the build config - native.genrule( - name = "{}_build_config_bazel".format(target), - srcs = [], - outs = ["build.config.msm.{}.generated".format(target)], - cmd_bash = """ - cat << 'EOF' > $@ + gen_config_command = """ + cat << 'EOF' > "$@" KERNEL_DIR="msm-kernel" -VARIANTS=(consolidate gki) +VARIANTS=(%s) MSM_ARCH=%s VARIANT=%s ABL_SRC=bootable/bootloader/edk2 @@ -89,25 +66,36 @@ fi KERNEL_VENDOR_CMDLINE+=' bootconfig ' VENDOR_BOOTCONFIG+='androidboot.first_stage_console=1 androidboot.hardware=qcom_kp' EOF - """ % ( - msm_target, - variant, - boot_image_header_version, - base_address, - page_size, - super_image_size, - int(lz4_ramdisk) - ), + """ % ( + " ".join(la_variants), + msm_target.replace("-", "_"), + variant.replace("-", "_"), + boot_image_opts.boot_image_header_version, + boot_image_opts.base_address, + boot_image_opts.page_size, + boot_image_opts.super_image_size, + int(boot_image_opts.lz4_ramdisk), ) + # Generate the build config + native.genrule( + name = "{}_build_config_bazel".format(target), + srcs = [], + outs = ["build.config.msm.{}.generated".format(target)], + cmd_bash = gen_config_command, + ) + + top_level_config = define_top_level_config(target) + common_config = gen_config_without_source_lines("build.config.common", target) + # Concatenate build config fragments to form the final config kernel_build_config( name = "{}_build_config".format(target), srcs = [ # do not sort - ":{}_top_level_config".format(target), + top_level_config, "build.config.constants", - ":{}_build_config_common_without_source".format(target), + common_config, "build.config.aarch64", ":{}_build_config_bazel".format(target), ] + [fragment for fragment in build_config_fragments] + [ @@ -116,7 +104,7 @@ EOF ], ) -def define_kernel_build( +def _define_kernel_build( target, base_kernel, in_tree_module_list, @@ -181,7 +169,7 @@ def define_kernel_build( kernel_build = ":{}".format(target), ) -def define_image_build( +def _define_image_build( target, msm_target, base_kernel, @@ -245,7 +233,7 @@ def define_image_build( ], ) -def define_kernel_dist(target, base_kernel): +def _define_kernel_dist(target, base_kernel): """Creates distribution targets for kernel builds When Bazel builds everything, the outputs end up buried in `bazel-bin`. @@ -256,6 +244,9 @@ def define_kernel_dist(target, base_kernel): target: name of main Bazel target (e.g. `kalama_gki`) base_kernel: base kernel to fetch artifacts from (e.g. `//common:kernel_aarch64`) """ + + dist_dir = "out/msm-kernel-{}/dist".format(target.replace("_", "-")) + msm_dist_targets = [ # do not sort base_kernel, @@ -271,7 +262,7 @@ def define_kernel_dist(target, base_kernel): name = "{}_abi_dist".format(target), kernel_build_abi = ":{}".format(target), data = msm_dist_targets, - dist_dir = "out/{}/dist".format(target), + dist_dir = dist_dir, flat = True, log = "info", ) @@ -279,7 +270,7 @@ def define_kernel_dist(target, base_kernel): copy_to_dist_dir( name = "{}_dist".format(target), data = msm_dist_targets, - dist_dir = "out/msm-kernel-{}/dist".format(target.replace("_", "-")), + dist_dir = dist_dir, flat = True, wipe_dist_dir = True, allow_duplicate_filenames = True, @@ -295,96 +286,24 @@ def define_kernel_dist(target, base_kernel): log = "info", ) -def define_dtc_dist(target): - """Create rules distribution target for device tree compiler and associated tools - - Args: - target: name of main Bazel target (e.g. `kalama_gki`) - """ - dtc_bin_targets = [ - "@dtc//:dtc", - "@dtc//:fdtget", - "@dtc//:fdtput", - "@dtc//:fdtdump", - "@dtc//:fdtoverlay", - "@dtc//:fdtoverlaymerge", - ] - dtc_lib_targets = [ - "@dtc//:dtc_gen", - "@dtc//:libfdt", - ] - dtc_inc_targets = [ - "@dtc//:libfdt/fdt.h", - "@dtc//:libfdt/libfdt.h", - "@dtc//:libfdt/libfdt_env.h", - ] - - dtc_tar_cmd = "mkdir -p bin lib include\n" - for label in dtc_bin_targets: - dtc_tar_cmd += "cp $(locations {}) bin/\n".format(label) - for label in dtc_lib_targets: - dtc_tar_cmd += "cp $(locations {}) lib/\n".format(label) - for label in dtc_inc_targets: - dtc_tar_cmd += "cp $(locations {}) include/\n".format(label) - dtc_tar_cmd += """ - chmod 755 bin/* lib/* - chmod 644 include/* - tar -czf "$@" bin lib include - """ - - native.genrule( - name = "{}_dtc_tarball".format(target), - srcs = dtc_bin_targets + dtc_lib_targets + dtc_inc_targets, - outs = ["{}_dtc.tar.gz".format(target)], - cmd = dtc_tar_cmd, - ) - native.alias( - name = "{}_dtc".format(target), - actual = ":{}_dtc_tarball".format(target), + name = "{}_test_mapping".format(target), + actual = ":{}_dist".format(target), ) - copy_to_dist_dir( - name = "{}_dtc_dist".format(target), - archives = [":{}_dtc_tarball".format(target)], - dist_dir = "out/msm-kernel-{}/host".format(target.replace("_", "-")), - flat = True, - wipe_dist_dir = True, - log = "info", + test_mappings_dist( + name = "{}_test_mapping_dist".format(target), + dist_dir = dist_dir, ) -def define_abl_dist(target): - """Creates ABL distribution target - - Args: - target: name of main Bazel target (e.g. `kalama_gki`) - """ - native.alias( - name = "{}_abl".format(target), - actual = "//bootable/bootloader/edk2:{}_abl".format(target), - ) - - copy_to_dist_dir( - name = "{}_abl_dist".format(target), - archives = ["{}_abl".format(target)], - dist_dir = "out/msm-kernel-{}/dist".format(target.replace("_", "-")), - flat = True, - wipe_dist_dir = False, - log = "info", - ) - -def define_msm( +def define_msm_la( msm_target, variant, in_tree_module_list, implicit_out_list = [], define_compile_commands = False, kmi_enforced = True, - boot_image_header_version = 4, - base_address = 0x80000000, - page_size = 4096, - super_image_size = 0x10000000, - lz4_ramdisk = True): + boot_image_opts = boot_image_opts()): """Top-level kernel build definition macro for an MSM platform Args: @@ -400,7 +319,13 @@ def define_msm( super_image_size: size of super image partition lz4_ramdisk: whether to use an lz4-compressed ramdisk """ - target = msm_target + "_" + variant + + if not variant in la_variants: + fail("{} not defined in target_variants.bzl la_variants!".format(variant)) + + # Enforce format of "//msm-kernel:target-foo_variant-bar" (underscore is the delimeter + # between target and variant) + target = msm_target.replace("_", "-") + "_" + variant.replace("_", "-") if variant == "consolidate": base_kernel = "//common:kernel_aarch64_consolidate" @@ -415,19 +340,15 @@ def define_msm( vendor_ramdisk_binaries = get_vendor_ramdisk_binaries(msm_target) build_config_fragments = get_build_config_fragments(msm_target) - define_build_config( + _define_build_config( msm_target, target, variant, - boot_image_header_version, - base_address, - page_size, - super_image_size, - lz4_ramdisk, - build_config_fragments, + boot_image_opts = boot_image_opts, + build_config_fragments = build_config_fragments, ) - define_kernel_build( + _define_kernel_build( target, base_kernel, in_tree_module_list, @@ -440,7 +361,7 @@ def define_msm( kmi_enforced, ) - define_image_build( + _define_image_build( target, msm_target, base_kernel, @@ -453,7 +374,7 @@ def define_msm( boot_image_outs = None if dtb_list else ["boot.img"], ) - define_kernel_dist(target, base_kernel) + _define_kernel_dist(target, base_kernel) define_abl_dist(target) diff --git a/msm_kernel_vm.bzl b/msm_kernel_vm.bzl new file mode 100644 index 000000000000..9520de78b184 --- /dev/null +++ b/msm_kernel_vm.bzl @@ -0,0 +1,258 @@ +load("//build/bazel_common_rules/dist:dist.bzl", "copy_to_dist_dir") +load("//build/bazel_common_rules/test_mappings:test_mappings.bzl", "test_mappings_dist") +load("//build/kernel/kleaf:constants.bzl", "aarch64_outs") +load( + "//build/kernel/kleaf:kernel.bzl", + "kernel_build", + "kernel_build_config", + "kernel_compile_commands", + "kernel_images", + "kernel_modules_install", + "merged_kernel_uapi_headers", +) +load( + "//build/bazel_extensions:msm_kernel_extensions.bzl", + "define_extras", + "get_build_config_fragments", + "get_dtb_list", + "get_dtbo_list", + "get_dtstree", + "get_vendor_ramdisk_binaries", +) +load(":msm_common.bzl", "define_top_level_config", "gen_config_without_source_lines") +load(":msm_dtc.bzl", "define_dtc_dist") +load(":image_opts.bzl", "vm_image_opts") +load(":target_variants.bzl", "vm_variants") + +def _define_build_config( + msm_target, + variant, + target, + vm_image_opts = vm_image_opts(), + build_config_fragments = []): + """Creates a kernel_build_config for an MSM target + + Creates a `kernel_build_config` for input to a `kernel_build` rule. + + Args: + msm_target: name of target platform (e.g. "kalama") + variant: variant of kernel to build (e.g. "gki") + target: combined name (e.g. "kalama_gki") + vm_image_opts: vm_image_opts structure containing boot image options + build_config_fragments: build.config fragments to embed + """ + + gen_config_command = """ + cat << 'EOF' > "$@" +KERNEL_DIR="msm-kernel" +VARIANTS=(%s) +MSM_ARCH=%s +VARIANT=%s + +PREFERRED_USERSPACE=%s +VM_DTB_IMG_CREATE=%d + +KERNEL_OFFSET=0x%X +DTB_OFFSET=0x%X +RAMDISK_OFFSET=0x%X + +VM_SIZE_EXT4=%d +DUMMY_IMG_SIZE=%d + +EOF + """ % ( + " ".join([v.replace("-", "_") for v in vm_variants]), # VARIANTS + msm_target.replace("-", "_"), # MSM_ARCH + variant.replace("-", "_"), # VARIANT + vm_image_opts.preferred_usespace, # PREFERED_USERSPACE + int(vm_image_opts.vm_dtb_img_create), # VM_DTB_IMG_CREATE + vm_image_opts.kernel_offset, # KERNEL_OFFSET + vm_image_opts.dtb_offset, # DTB_OFFSET + vm_image_opts.ramdisk_offset, # RAMDISK_OFFSET + vm_image_opts.vm_size_ext4, # VM_SIZE_EXT4 + vm_image_opts.dummy_img_size, # DUMMY_IMG_SIZE + ) + + # Generate the build config + native.genrule( + name = "{}_build_config_bazel".format(target), + srcs = [], + outs = ["build.config.msm.{}.generated".format(target)], + cmd_bash = gen_config_command, + ) + + top_level_config = define_top_level_config(target) + common_config = gen_config_without_source_lines("build.config.common", target) + + # Concatenate build config fragments to form the final config + kernel_build_config( + name = "{}_build_config".format(target), + srcs = [ + # do not sort + top_level_config, + "build.config.constants", + common_config, + "build.config.aarch64", + ":{}_build_config_bazel".format(target), + ] + [fragment for fragment in build_config_fragments] + [ + "build.config.msm.common", + "build.config.msm.vm", + ], + ) + +def _define_kernel_build( + target, + dtb_list, + dtbo_list, + dtstree, + define_compile_commands): + """Creates a `kernel_build` and other associated definitions + + This is where the main kernel build target is created (e.g. `//msm-kernel:kalama_gki`). + Many other rules will take this `kernel_build` as an input. + + Args: + target: name of main Bazel target (e.g. `kalama_gki`) + dtb_list: device tree blobs expected to be built + dtbo_list: device tree overlay blobs expected to be built + define_compile_commands: boolean determining if `compile_commands.json` should be generated + """ + out_list = [".config", "Module.symvers"] + + if dtb_list: + out_list += dtb_list + if dtbo_list: + out_list += dtbo_list + + # Add basic kernel outputs + out_list += aarch64_outs + + # VM builds don't build compressed, so remove from list + out_list.remove("Image.lz4") + out_list.remove("Image.gz") + + kernel_build( + name = target, + outs = out_list, + build_config = ":{}_build_config".format(target), + dtstree = dtstree, + kmi_symbol_list = None, + additional_kmi_symbol_lists = None, + abi_definition = None, + enable_interceptor = define_compile_commands, + visibility = ["//visibility:public"], + ) + + kernel_images( + name = "{}_images".format(target), + kernel_build = ":{}".format(target), + boot_image_outs = ["dtb.img"], + build_boot = True, + kernel_modules_install = None, + ) + + merged_kernel_uapi_headers( + name = "{}_merged_kernel_uapi_headers".format(target), + kernel_build = ":{}".format(target), + ) + + if define_compile_commands: + kernel_compile_commands( + name = "{}_compile_commands".format(target), + kernel_build = ":{}".format(target), + ) + +def _define_kernel_dist(target): + """Creates distribution targets for kernel builds + + When Bazel builds everything, the outputs end up buried in `bazel-bin`. + These rules are used to copy the build artifacts to `out/msm-kernel-/dist/` + with proper permissions, etc. + + Args: + target: name of main Bazel target (e.g. `kalama_gki`) + """ + + dist_dir = "out/msm-kernel-{}/dist".format(target.replace("_", "-")) + + msm_dist_targets = [ + # do not sort + ":{}".format(target), + ":{}_merged_kernel_uapi_headers".format(target), + ":{}_build_config".format(target), + ] + + copy_to_dist_dir( + name = "{}_dist".format(target), + data = msm_dist_targets, + dist_dir = dist_dir, + flat = True, + wipe_dist_dir = True, + allow_duplicate_filenames = True, + mode_overrides = { + # do not sort + "**/vmlinux": "755", + "**/Image": "755", + "**/*.dtb*": "755", + "**/*": "644", + }, + log = "info", + ) + + native.alias( + name = "{}_test_mapping".format(target), + actual = ":{}_dist".format(target), + ) + + test_mappings_dist( + name = "{}_test_mapping_dist".format(target), + dist_dir = dist_dir, + ) + +def define_msm_vm( + msm_target, + variant, + define_compile_commands = False, + vm_image_opts = vm_image_opts()): + """Top-level kernel build definition macro for a VM MSM platform + + Args: + msm_target: name of target platform (e.g. "kalama") + variant: variant of kernel to build (e.g. "gki") + define_compile_commands: boolean determining if `compile_commands.json` should be generated + vm_image_opts: vm_image_opts structure containing boot image options + """ + + if not variant in vm_variants: + fail("{} not defined in target_variants.bzl vm_variants!".format(variant)) + + # Enforce format of "//msm-kernel:target-foo_variant-bar" (underscore is the delimeter + # between target and variant) + target = msm_target.replace("_", "-") + "_" + variant.replace("_", "-") + + dtb_list = get_dtb_list(msm_target) + dtbo_list = get_dtbo_list(msm_target) + dtstree = get_dtstree(msm_target) + build_config_fragments = get_build_config_fragments(msm_target) + + _define_build_config( + msm_target, + variant, + target, + vm_image_opts = vm_image_opts, + build_config_fragments = build_config_fragments, + ) + + _define_kernel_build( + target, + dtb_list, + dtbo_list, + dtstree, + define_compile_commands, + ) + + _define_kernel_dist(target) + + define_dtc_dist(target) + + define_extras(target, flavor = "vm") diff --git a/msm_platforms.bzl b/msm_platforms.bzl index 3e03c2e5419a..2165bc7a5edb 100644 --- a/msm_platforms.bzl +++ b/msm_platforms.bzl @@ -1,6 +1,10 @@ load(":kalama.bzl", "define_kalama") +load(":kalama_tuivm.bzl", "define_kalama_tuivm") load(":pineapple.bzl", "define_pineapple") +load(":pineapple_tuivm.bzl", "define_pineapple_tuivm") def define_msm_platforms(): define_kalama() + define_kalama_tuivm() define_pineapple() + define_pineapple_tuivm() diff --git a/pineapple.bzl b/pineapple.bzl index b1857be1c65b..a0645729210e 100644 --- a/pineapple.bzl +++ b/pineapple.bzl @@ -1,5 +1,5 @@ -load(":target_variants.bzl", "targets", "variants") -load(":msm_kernel.bzl", "define_msm") +load(":target_variants.bzl", "la_variants") +load(":msm_kernel_la.bzl", "define_msm_la") target_name = "pineapple" @@ -191,16 +191,13 @@ def define_pineapple(): "mm/zsmalloc.ko", ] - if not target_name in targets: - fail("{} not defined in target_variants.bzl".format(target_name)) - - for variant in variants: + for variant in la_variants: if variant == "consolidate": mod_list = _pineapple_consolidate_in_tree_modules else: mod_list = _pineapple_in_tree_modules - define_msm( + define_msm_la( msm_target = target_name, variant = variant, in_tree_module_list = mod_list, diff --git a/pineapple_tuivm.bzl b/pineapple_tuivm.bzl new file mode 100644 index 000000000000..068fbd803bb2 --- /dev/null +++ b/pineapple_tuivm.bzl @@ -0,0 +1,11 @@ +load(":target_variants.bzl", "vm_variants") +load(":msm_kernel_vm.bzl", "define_msm_vm") + +target_name = "pineapple-tuivm" + +def define_pineapple_tuivm(): + for variant in vm_variants: + define_msm_vm( + msm_target = target_name, + variant = variant, + ) diff --git a/target_variants.bzl b/target_variants.bzl index 15b5f0dd3c6d..eda56ecb4979 100644 --- a/target_variants.bzl +++ b/target_variants.bzl @@ -4,11 +4,30 @@ targets = [ "pineapple", ] -variants = [ +la_variants = [ # keep sorted "consolidate", "gki", ] +vm_types = [ + "tuivm", + # "oemvm", +] + +vm_targets = ["{}-{}".format(t, vt) for t in targets for vt in vm_types] + +vm_variants = [ + # keep sorted + "debug-defconfig", + "defconfig", +] + +def get_all_la_variants(): + return [(t, v) for t in targets for v in la_variants] + +def get_all_vm_variants(): + return [(t, v) for t in vm_targets for v in vm_variants] + def get_all_variants(): - return [(t, v) for t in targets for v in variants] + return get_all_la_variants() + get_all_vm_variants()