android/android_kernel_samsung_sm8650
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

build: Add support for Bazel VM builds

Browse Source 
Currently, only legacy build.sh support exists for VM
builds.

Add Bazel support for these builds.

Change-Id: I10b221aa4a6633240b984eff333e15f5cd8b82cd
Signed-off-by: John Moon <quic_johmoo@quicinc.com>
This commit is contained in:
John Moon 2022-10-24 18:04:53 -07:00
parent f852a8b67d
commit 8503690aa2
14 changed files with 523 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
build_with_bazel.py
View File

@ -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:

31
image_opts.bzl Normal file
View File

@ -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,
)

12
kalama.bzl
View File

@ -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,

11
kalama_tuivm.bzl Normal file
View File

@ -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,
)

21
msm_abl.bzl Normal file
View File

@ -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",
)

34
msm_common.bzl Normal file
View File

@ -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

59
msm_dtc.bzl Normal file
View File

@ -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",
)

2
msm_kernel_extensions.bzl
View File

@ -1,4 +1,4 @@
def define_extras(target):
def define_extras(target, flavor = None):
return
def get_build_config_fragments(target):

199
msm_kernel.bzl → msm_kernel_la.bzl
View File

@ -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
@ -90,24 +67,35 @@ 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)

258
msm_kernel_vm.bzl Normal file
View File

@ -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-<target>/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")

4
msm_platforms.bzl
View File

@ -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()

11
pineapple.bzl
View File

@ -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,

11
pineapple_tuivm.bzl Normal file
View File

@ -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,
)

23
target_variants.bzl
View File

@ -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()