| package bp2build |
| |
| import ( |
| "encoding/json" |
| "fmt" |
| "os" |
| "path/filepath" |
| "reflect" |
| "sort" |
| "strings" |
| |
| "android/soong/android" |
| "android/soong/android/soongconfig" |
| "android/soong/starlark_import" |
| |
| "github.com/google/blueprint/proptools" |
| "go.starlark.net/starlark" |
| ) |
| |
| type createProductConfigFilesResult struct { |
| injectionFiles []BazelFile |
| bp2buildFiles []BazelFile |
| bp2buildTargets map[string]BazelTargets |
| } |
| |
| type bazelLabel struct { |
| repo string |
| pkg string |
| target string |
| } |
| |
| func (l *bazelLabel) Less(other *bazelLabel) bool { |
| if l.repo < other.repo { |
| return true |
| } |
| if l.repo > other.repo { |
| return false |
| } |
| if l.pkg < other.pkg { |
| return true |
| } |
| if l.pkg > other.pkg { |
| return false |
| } |
| return l.target < other.target |
| } |
| |
| func (l *bazelLabel) String() string { |
| return fmt.Sprintf("@%s//%s:%s", l.repo, l.pkg, l.target) |
| } |
| |
| func createProductConfigFiles( |
| ctx *CodegenContext, |
| metrics CodegenMetrics) (createProductConfigFilesResult, error) { |
| cfg := &ctx.config |
| targetProduct := "unknown" |
| if cfg.HasDeviceProduct() { |
| targetProduct = cfg.DeviceProduct() |
| } |
| targetBuildVariant := "user" |
| if cfg.Eng() { |
| targetBuildVariant = "eng" |
| } else if cfg.Debuggable() { |
| targetBuildVariant = "userdebug" |
| } |
| |
| var res createProductConfigFilesResult |
| |
| productVariablesFileName := cfg.ProductVariablesFileName |
| if !strings.HasPrefix(productVariablesFileName, "/") { |
| productVariablesFileName = filepath.Join(ctx.topDir, productVariablesFileName) |
| } |
| productVariablesBytes, err := os.ReadFile(productVariablesFileName) |
| if err != nil { |
| return res, err |
| } |
| productVariables := android.ProductVariables{} |
| err = json.Unmarshal(productVariablesBytes, &productVariables) |
| if err != nil { |
| return res, err |
| } |
| |
| currentProductFolder := fmt.Sprintf("build/bazel/products/%s", targetProduct) |
| if len(productVariables.PartitionVarsForBazelMigrationOnlyDoNotUse.ProductDirectory) > 0 { |
| currentProductFolder = fmt.Sprintf("%s%s", productVariables.PartitionVarsForBazelMigrationOnlyDoNotUse.ProductDirectory, targetProduct) |
| } |
| |
| productReplacer := strings.NewReplacer( |
| "{PRODUCT}", targetProduct, |
| "{VARIANT}", targetBuildVariant, |
| "{PRODUCT_FOLDER}", currentProductFolder) |
| |
| productsForTestingMap, err := starlark_import.GetStarlarkValue[map[string]map[string]starlark.Value]("products_for_testing") |
| if err != nil { |
| return res, err |
| } |
| productsForTesting := android.SortedKeys(productsForTestingMap) |
| for i := range productsForTesting { |
| productsForTesting[i] = fmt.Sprintf(" \"@//build/bazel/tests/products:%s\",", productsForTesting[i]) |
| } |
| |
| productLabelsToVariables := make(map[bazelLabel]*android.ProductVariables) |
| productLabelsToVariables[bazelLabel{ |
| repo: "", |
| pkg: currentProductFolder, |
| target: targetProduct, |
| }] = &productVariables |
| for product, productVariablesStarlark := range productsForTestingMap { |
| productVariables, err := starlarkMapToProductVariables(productVariablesStarlark) |
| if err != nil { |
| return res, err |
| } |
| productLabelsToVariables[bazelLabel{ |
| repo: "", |
| pkg: "build/bazel/tests/products", |
| target: product, |
| }] = &productVariables |
| } |
| |
| res.bp2buildTargets = make(map[string]BazelTargets) |
| res.bp2buildTargets[currentProductFolder] = append(res.bp2buildTargets[currentProductFolder], BazelTarget{ |
| name: productReplacer.Replace("{PRODUCT}"), |
| packageName: currentProductFolder, |
| content: productReplacer.Replace(`android_product( |
| name = "{PRODUCT}", |
| soong_variables = _soong_variables, |
| )`), |
| ruleClass: "android_product", |
| loads: []BazelLoad{ |
| { |
| file: ":soong.variables.bzl", |
| symbols: []BazelLoadSymbol{{ |
| symbol: "variables", |
| alias: "_soong_variables", |
| }}, |
| }, |
| { |
| file: "//build/bazel/product_config:android_product.bzl", |
| symbols: []BazelLoadSymbol{{symbol: "android_product"}}, |
| }, |
| }, |
| }) |
| createTargets(productLabelsToVariables, res.bp2buildTargets) |
| |
| platformMappingContent, err := platformMappingContent( |
| productLabelsToVariables, |
| ctx.Config().Bp2buildSoongConfigDefinitions, |
| metrics.convertedModulePathMap) |
| if err != nil { |
| return res, err |
| } |
| |
| res.injectionFiles = []BazelFile{ |
| newFile( |
| "product_config_platforms", |
| "BUILD.bazel", |
| productReplacer.Replace(` |
| package(default_visibility = [ |
| "@//build/bazel/product_config:__subpackages__", |
| "@soong_injection//product_config_platforms:__subpackages__", |
| ]) |
| |
| load("@//{PRODUCT_FOLDER}:soong.variables.bzl", _soong_variables = "variables") |
| load("@//build/bazel/product_config:android_product.bzl", "android_product") |
| |
| # Bazel will qualify its outputs by the platform name. When switching between products, this |
| # means that soong-built files that depend on bazel-built files will suddenly get different |
| # dependency files, because the path changes, and they will be rebuilt. In order to avoid this |
| # extra rebuilding, make mixed builds always use a single platform so that the bazel artifacts |
| # are always under the same path. |
| android_product( |
| name = "mixed_builds_product", |
| soong_variables = _soong_variables, |
| extra_constraints = ["@//build/bazel/platforms:mixed_builds"], |
| ) |
| `)), |
| newFile( |
| "product_config_platforms", |
| "product_labels.bzl", |
| productReplacer.Replace(` |
| # This file keeps a list of all the products in the android source tree, because they're |
| # discovered as part of a preprocessing step before bazel runs. |
| # TODO: When we start generating the platforms for more than just the |
| # currently lunched product, they should all be listed here |
| product_labels = [ |
| "@soong_injection//product_config_platforms:mixed_builds_product", |
| "@//{PRODUCT_FOLDER}:{PRODUCT}", |
| `)+strings.Join(productsForTesting, "\n")+"\n]\n"), |
| newFile( |
| "product_config_platforms", |
| "common.bazelrc", |
| productReplacer.Replace(` |
| build --platform_mappings=platform_mappings |
| build --platforms @//{PRODUCT_FOLDER}:{PRODUCT}_linux_x86_64 |
| build --//build/bazel/product_config:target_build_variant={VARIANT} |
| |
| build:android --platforms=@//{PRODUCT_FOLDER}:{PRODUCT} |
| build:linux_x86 --platforms=@//{PRODUCT_FOLDER}:{PRODUCT}_linux_x86 |
| build:linux_x86_64 --platforms=@//{PRODUCT_FOLDER}:{PRODUCT}_linux_x86_64 |
| build:linux_bionic_x86_64 --platforms=@//{PRODUCT_FOLDER}:{PRODUCT}_linux_bionic_x86_64 |
| build:linux_musl_x86 --platforms=@//{PRODUCT_FOLDER}:{PRODUCT}_linux_musl_x86 |
| build:linux_musl_x86_64 --platforms=@//{PRODUCT_FOLDER}:{PRODUCT}_linux_musl_x86_64 |
| `)), |
| newFile( |
| "product_config_platforms", |
| "linux.bazelrc", |
| productReplacer.Replace(` |
| build --host_platform @//{PRODUCT_FOLDER}:{PRODUCT}_linux_x86_64 |
| `)), |
| newFile( |
| "product_config_platforms", |
| "darwin.bazelrc", |
| productReplacer.Replace(` |
| build --host_platform @//{PRODUCT_FOLDER}:{PRODUCT}_darwin_x86_64 |
| `)), |
| } |
| res.bp2buildFiles = []BazelFile{ |
| newFile( |
| "", |
| "platform_mappings", |
| platformMappingContent), |
| newFile( |
| currentProductFolder, |
| "soong.variables.bzl", |
| `variables = json.decode("""`+strings.ReplaceAll(string(productVariablesBytes), "\\", "\\\\")+`""")`), |
| } |
| |
| return res, nil |
| } |
| |
| func platformMappingContent( |
| productLabelToVariables map[bazelLabel]*android.ProductVariables, |
| soongConfigDefinitions soongconfig.Bp2BuildSoongConfigDefinitions, |
| convertedModulePathMap map[string]string) (string, error) { |
| var result strings.Builder |
| |
| mergedConvertedModulePathMap := make(map[string]string) |
| for k, v := range convertedModulePathMap { |
| mergedConvertedModulePathMap[k] = v |
| } |
| additionalModuleNamesToPackages, err := starlark_import.GetStarlarkValue[map[string]string]("additional_module_names_to_packages") |
| if err != nil { |
| return "", err |
| } |
| for k, v := range additionalModuleNamesToPackages { |
| mergedConvertedModulePathMap[k] = v |
| } |
| |
| productLabels := make([]bazelLabel, 0, len(productLabelToVariables)) |
| for k := range productLabelToVariables { |
| productLabels = append(productLabels, k) |
| } |
| sort.Slice(productLabels, func(i, j int) bool { |
| return productLabels[i].Less(&productLabels[j]) |
| }) |
| result.WriteString("platforms:\n") |
| for _, productLabel := range productLabels { |
| platformMappingSingleProduct(productLabel, productLabelToVariables[productLabel], soongConfigDefinitions, mergedConvertedModulePathMap, &result) |
| } |
| return result.String(), nil |
| } |
| |
| var bazelPlatformSuffixes = []string{ |
| "", |
| "_darwin_arm64", |
| "_darwin_x86_64", |
| "_linux_bionic_arm64", |
| "_linux_bionic_x86_64", |
| "_linux_musl_x86", |
| "_linux_musl_x86_64", |
| "_linux_x86", |
| "_linux_x86_64", |
| "_windows_x86", |
| "_windows_x86_64", |
| } |
| |
| func platformMappingSingleProduct( |
| label bazelLabel, |
| productVariables *android.ProductVariables, |
| soongConfigDefinitions soongconfig.Bp2BuildSoongConfigDefinitions, |
| convertedModulePathMap map[string]string, |
| result *strings.Builder) { |
| |
| platform_sdk_version := -1 |
| if productVariables.Platform_sdk_version != nil { |
| platform_sdk_version = *productVariables.Platform_sdk_version |
| } |
| |
| defaultAppCertificateFilegroup := "//build/bazel/utils:empty_filegroup" |
| if proptools.String(productVariables.DefaultAppCertificate) != "" { |
| defaultAppCertificateFilegroup = "@//" + filepath.Dir(proptools.String(productVariables.DefaultAppCertificate)) + ":generated_android_certificate_directory" |
| } |
| |
| // TODO: b/301598690 - commas can't be escaped in a string-list passed in a platform mapping, |
| // so commas are switched for ":" here, and must be back-substituted into commas |
| // wherever the AAPTCharacteristics product config variable is used. |
| AAPTConfig := []string{} |
| for _, conf := range productVariables.AAPTConfig { |
| AAPTConfig = append(AAPTConfig, strings.Replace(conf, ",", ":", -1)) |
| } |
| |
| for _, suffix := range bazelPlatformSuffixes { |
| result.WriteString(" ") |
| result.WriteString(label.String()) |
| result.WriteString(suffix) |
| result.WriteString("\n") |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:aapt_characteristics=%s\n", proptools.String(productVariables.AAPTCharacteristics))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:aapt_config=%s\n", strings.Join(AAPTConfig, ","))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:aapt_preferred_config=%s\n", proptools.String(productVariables.AAPTPreferredConfig))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:always_use_prebuilt_sdks=%t\n", proptools.Bool(productVariables.Always_use_prebuilt_sdks))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:arc=%t\n", proptools.Bool(productVariables.Arc))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:apex_global_min_sdk_version_override=%s\n", proptools.String(productVariables.ApexGlobalMinSdkVersionOverride))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:binder32bit=%t\n", proptools.Bool(productVariables.Binder32bit))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:build_from_text_stub=%t\n", proptools.Bool(productVariables.Build_from_text_stub))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:build_broken_incorrect_partition_images=%t\n", productVariables.BuildBrokenIncorrectPartitionImages)) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:build_id=%s\n", proptools.String(productVariables.BuildId))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:build_version_tags=%s\n", strings.Join(productVariables.BuildVersionTags, ","))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:cfi_exclude_paths=%s\n", strings.Join(productVariables.CFIExcludePaths, ","))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:cfi_include_paths=%s\n", strings.Join(productVariables.CFIIncludePaths, ","))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:compressed_apex=%t\n", proptools.Bool(productVariables.CompressedApex))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:default_app_certificate=%s\n", proptools.String(productVariables.DefaultAppCertificate))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:default_app_certificate_filegroup=%s\n", defaultAppCertificateFilegroup)) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:device_abi=%s\n", strings.Join(productVariables.DeviceAbi, ","))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:device_max_page_size_supported=%s\n", proptools.String(productVariables.DeviceMaxPageSizeSupported))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:device_name=%s\n", proptools.String(productVariables.DeviceName))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:device_page_size_agnostic=%t\n", proptools.Bool(productVariables.DevicePageSizeAgnostic))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:device_product=%s\n", proptools.String(productVariables.DeviceProduct))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:device_platform=%s\n", label.String())) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:enable_cfi=%t\n", proptools.BoolDefault(productVariables.EnableCFI, true))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:enforce_vintf_manifest=%t\n", proptools.Bool(productVariables.Enforce_vintf_manifest))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:malloc_not_svelte=%t\n", proptools.Bool(productVariables.Malloc_not_svelte))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:malloc_pattern_fill_contents=%t\n", proptools.Bool(productVariables.Malloc_pattern_fill_contents))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:malloc_zero_contents=%t\n", proptools.Bool(productVariables.Malloc_zero_contents))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:memtag_heap_exclude_paths=%s\n", strings.Join(productVariables.MemtagHeapExcludePaths, ","))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:memtag_heap_async_include_paths=%s\n", strings.Join(productVariables.MemtagHeapAsyncIncludePaths, ","))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:memtag_heap_sync_include_paths=%s\n", strings.Join(productVariables.MemtagHeapSyncIncludePaths, ","))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:manifest_package_name_overrides=%s\n", strings.Join(productVariables.ManifestPackageNameOverrides, ","))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:native_coverage=%t\n", proptools.Bool(productVariables.Native_coverage))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:platform_sdk_final=%t\n", proptools.Bool(productVariables.Platform_sdk_final))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:platform_security_patch=%s\n", proptools.String(productVariables.Platform_security_patch))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:platform_version_last_stable=%s\n", proptools.String(productVariables.Platform_version_last_stable))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:platform_version_name=%s\n", proptools.String(productVariables.Platform_version_name))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:product_brand=%s\n", productVariables.ProductBrand)) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:product_manufacturer=%s\n", productVariables.ProductManufacturer)) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:release_aconfig_flag_default_permission=%s\n", productVariables.ReleaseAconfigFlagDefaultPermission)) |
| // Empty string can't be used as label_flag on the bazel side |
| if len(productVariables.ReleaseAconfigValueSets) > 0 { |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:release_aconfig_value_sets=%s\n", productVariables.ReleaseAconfigValueSets)) |
| } |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:release_version=%s\n", productVariables.ReleaseVersion)) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:platform_sdk_version=%d\n", platform_sdk_version)) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:safestack=%t\n", proptools.Bool(productVariables.Safestack))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:treble_linker_namespaces=%t\n", proptools.Bool(productVariables.Treble_linker_namespaces))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:tidy_checks=%s\n", proptools.String(productVariables.TidyChecks))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:uml=%t\n", proptools.Bool(productVariables.Uml))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:unbundled_build=%t\n", proptools.Bool(productVariables.Unbundled_build))) |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config:unbundled_build_apps=%s\n", strings.Join(productVariables.Unbundled_build_apps, ","))) |
| |
| for _, override := range productVariables.CertificateOverrides { |
| parts := strings.SplitN(override, ":", 2) |
| if apexPath, ok := convertedModulePathMap[parts[0]]; ok { |
| if overrideCertPath, ok := convertedModulePathMap[parts[1]]; ok { |
| result.WriteString(fmt.Sprintf(" --%s:%s_certificate_override=%s:%s\n", apexPath, parts[0], overrideCertPath, parts[1])) |
| } |
| } |
| } |
| |
| for _, namespace := range android.SortedKeys(productVariables.VendorVars) { |
| for _, variable := range android.SortedKeys(productVariables.VendorVars[namespace]) { |
| value := productVariables.VendorVars[namespace][variable] |
| key := namespace + "__" + variable |
| _, hasBool := soongConfigDefinitions.BoolVars[key] |
| _, hasString := soongConfigDefinitions.StringVars[key] |
| _, hasValue := soongConfigDefinitions.ValueVars[key] |
| if !hasBool && !hasString && !hasValue { |
| // Not all soong config variables are defined in Android.bp files. For example, |
| // prebuilt_bootclasspath_fragment uses soong config variables in a nonstandard |
| // way, that causes them to be present in the soong.variables file but not |
| // defined in an Android.bp file. There's also nothing stopping you from setting |
| // a variable in make that doesn't exist in soong. We only generate build |
| // settings for the ones that exist in soong, so skip all others. |
| continue |
| } |
| if hasBool && hasString || hasBool && hasValue || hasString && hasValue { |
| panic(fmt.Sprintf("Soong config variable %s:%s appears to be of multiple types. bool? %t, string? %t, value? %t", namespace, variable, hasBool, hasString, hasValue)) |
| } |
| if hasBool { |
| // Logic copied from soongConfig.Bool() |
| value = strings.ToLower(value) |
| if value == "1" || value == "y" || value == "yes" || value == "on" || value == "true" { |
| value = "true" |
| } else { |
| value = "false" |
| } |
| } |
| result.WriteString(fmt.Sprintf(" --//build/bazel/product_config/soong_config_variables:%s=%s\n", strings.ToLower(key), value)) |
| } |
| } |
| } |
| } |
| |
| func starlarkMapToProductVariables(in map[string]starlark.Value) (android.ProductVariables, error) { |
| result := android.ProductVariables{} |
| productVarsReflect := reflect.ValueOf(&result).Elem() |
| for i := 0; i < productVarsReflect.NumField(); i++ { |
| field := productVarsReflect.Field(i) |
| fieldType := productVarsReflect.Type().Field(i) |
| name := fieldType.Name |
| if name == "BootJars" || name == "ApexBootJars" || name == "VendorSnapshotModules" || |
| name == "RecoverySnapshotModules" { |
| // These variables have more complicated types, and we don't need them right now |
| continue |
| } |
| if _, ok := in[name]; ok { |
| if name == "VendorVars" { |
| vendorVars, err := starlark_import.Unmarshal[map[string]map[string]string](in[name]) |
| if err != nil { |
| return result, err |
| } |
| field.Set(reflect.ValueOf(vendorVars)) |
| continue |
| } |
| switch field.Type().Kind() { |
| case reflect.Bool: |
| val, err := starlark_import.Unmarshal[bool](in[name]) |
| if err != nil { |
| return result, err |
| } |
| field.SetBool(val) |
| case reflect.String: |
| val, err := starlark_import.Unmarshal[string](in[name]) |
| if err != nil { |
| return result, err |
| } |
| field.SetString(val) |
| case reflect.Slice: |
| if field.Type().Elem().Kind() != reflect.String { |
| return result, fmt.Errorf("slices of types other than strings are unimplemented") |
| } |
| val, err := starlark_import.UnmarshalReflect(in[name], field.Type()) |
| if err != nil { |
| return result, err |
| } |
| field.Set(val) |
| case reflect.Pointer: |
| switch field.Type().Elem().Kind() { |
| case reflect.Bool: |
| val, err := starlark_import.UnmarshalNoneable[bool](in[name]) |
| if err != nil { |
| return result, err |
| } |
| field.Set(reflect.ValueOf(val)) |
| case reflect.String: |
| val, err := starlark_import.UnmarshalNoneable[string](in[name]) |
| if err != nil { |
| return result, err |
| } |
| field.Set(reflect.ValueOf(val)) |
| case reflect.Int: |
| val, err := starlark_import.UnmarshalNoneable[int](in[name]) |
| if err != nil { |
| return result, err |
| } |
| field.Set(reflect.ValueOf(val)) |
| default: |
| return result, fmt.Errorf("pointers of types other than strings/bools are unimplemented: %s", field.Type().Elem().Kind().String()) |
| } |
| default: |
| return result, fmt.Errorf("unimplemented type: %s", field.Type().String()) |
| } |
| } |
| } |
| |
| result.Native_coverage = proptools.BoolPtr( |
| proptools.Bool(result.GcovCoverage) || |
| proptools.Bool(result.ClangCoverage)) |
| |
| return result, nil |
| } |
| |
| func createTargets(productLabelsToVariables map[bazelLabel]*android.ProductVariables, res map[string]BazelTargets) { |
| createGeneratedAndroidCertificateDirectories(productLabelsToVariables, res) |
| createAvbKeyFilegroups(productLabelsToVariables, res) |
| for label, variables := range productLabelsToVariables { |
| createSystemPartition(label, &variables.PartitionVarsForBazelMigrationOnlyDoNotUse, res) |
| } |
| } |
| |
| func createGeneratedAndroidCertificateDirectories(productLabelsToVariables map[bazelLabel]*android.ProductVariables, targets map[string]BazelTargets) { |
| var allDefaultAppCertificateDirs []string |
| for _, productVariables := range productLabelsToVariables { |
| if proptools.String(productVariables.DefaultAppCertificate) != "" { |
| d := filepath.Dir(proptools.String(productVariables.DefaultAppCertificate)) |
| if !android.InList(d, allDefaultAppCertificateDirs) { |
| allDefaultAppCertificateDirs = append(allDefaultAppCertificateDirs, d) |
| } |
| } |
| } |
| for _, dir := range allDefaultAppCertificateDirs { |
| content := `filegroup( |
| name = "generated_android_certificate_directory", |
| srcs = glob([ |
| "*.pk8", |
| "*.pem", |
| "*.avbpubkey", |
| ]), |
| visibility = ["//visibility:public"], |
| )` |
| targets[dir] = append(targets[dir], BazelTarget{ |
| name: "generated_android_certificate_directory", |
| packageName: dir, |
| content: content, |
| ruleClass: "filegroup", |
| }) |
| } |
| } |
| |
| func createAvbKeyFilegroups(productLabelsToVariables map[bazelLabel]*android.ProductVariables, targets map[string]BazelTargets) { |
| var allAvbKeys []string |
| for _, productVariables := range productLabelsToVariables { |
| for _, partitionVariables := range productVariables.PartitionVarsForBazelMigrationOnlyDoNotUse.PartitionQualifiedVariables { |
| if partitionVariables.BoardAvbKeyPath != "" { |
| if !android.InList(partitionVariables.BoardAvbKeyPath, allAvbKeys) { |
| allAvbKeys = append(allAvbKeys, partitionVariables.BoardAvbKeyPath) |
| } |
| } |
| } |
| } |
| for _, key := range allAvbKeys { |
| dir := filepath.Dir(key) |
| name := filepath.Base(key) |
| content := fmt.Sprintf(`filegroup( |
| name = "%s_filegroup", |
| srcs = ["%s"], |
| visibility = ["//visibility:public"], |
| )`, name, name) |
| targets[dir] = append(targets[dir], BazelTarget{ |
| name: name + "_filegroup", |
| packageName: dir, |
| content: content, |
| ruleClass: "filegroup", |
| }) |
| } |
| } |
| |
| func createSystemPartition(platformLabel bazelLabel, variables *android.PartitionVariables, targets map[string]BazelTargets) { |
| if !variables.PartitionQualifiedVariables["system"].BuildingImage { |
| return |
| } |
| qualifiedVariables := variables.PartitionQualifiedVariables["system"] |
| |
| imageProps := generateImagePropDictionary(variables, "system") |
| imageProps["skip_fsck"] = "true" |
| |
| var properties strings.Builder |
| for _, prop := range android.SortedKeys(imageProps) { |
| properties.WriteString(prop) |
| properties.WriteRune('=') |
| properties.WriteString(imageProps[prop]) |
| properties.WriteRune('\n') |
| } |
| |
| var extraProperties strings.Builder |
| if variables.BoardAvbEnable { |
| extraProperties.WriteString(" avb_enable = True,\n") |
| extraProperties.WriteString(fmt.Sprintf(" avb_add_hashtree_footer_args = %q,\n", qualifiedVariables.BoardAvbAddHashtreeFooterArgs)) |
| keypath := qualifiedVariables.BoardAvbKeyPath |
| if keypath != "" { |
| extraProperties.WriteString(fmt.Sprintf(" avb_key = \"//%s:%s\",\n", filepath.Dir(keypath), filepath.Base(keypath)+"_filegroup")) |
| extraProperties.WriteString(fmt.Sprintf(" avb_algorithm = %q,\n", qualifiedVariables.BoardAvbAlgorithm)) |
| extraProperties.WriteString(fmt.Sprintf(" avb_rollback_index = %s,\n", qualifiedVariables.BoardAvbRollbackIndex)) |
| extraProperties.WriteString(fmt.Sprintf(" avb_rollback_index_location = %s,\n", qualifiedVariables.BoardAvbRollbackIndexLocation)) |
| } |
| } |
| |
| targets[platformLabel.pkg] = append(targets[platformLabel.pkg], BazelTarget{ |
| name: "system_image", |
| packageName: platformLabel.pkg, |
| content: fmt.Sprintf(`partition( |
| name = "system_image", |
| base_staging_dir = "//build/bazel/bazel_sandwich:system_staging_dir", |
| base_staging_dir_file_list = "//build/bazel/bazel_sandwich:system_staging_dir_file_list", |
| root_dir = "//build/bazel/bazel_sandwich:root_staging_dir", |
| selinux_file_contexts = "//build/bazel/bazel_sandwich:selinux_file_contexts", |
| image_properties = """ |
| %s |
| """, |
| %s |
| type = "system", |
| )`, properties.String(), extraProperties.String()), |
| ruleClass: "partition", |
| loads: []BazelLoad{{ |
| file: "//build/bazel/rules/partitions:partition.bzl", |
| symbols: []BazelLoadSymbol{{ |
| symbol: "partition", |
| }}, |
| }}, |
| }, BazelTarget{ |
| name: "system_image_test", |
| packageName: platformLabel.pkg, |
| content: `partition_diff_test( |
| name = "system_image_test", |
| partition1 = "//build/bazel/bazel_sandwich:make_system_image", |
| partition2 = ":system_image", |
| )`, |
| ruleClass: "partition_diff_test", |
| loads: []BazelLoad{{ |
| file: "//build/bazel/rules/partitions/diff:partition_diff.bzl", |
| symbols: []BazelLoadSymbol{{ |
| symbol: "partition_diff_test", |
| }}, |
| }}, |
| }, BazelTarget{ |
| name: "run_system_image_test", |
| packageName: platformLabel.pkg, |
| content: `run_test_in_build( |
| name = "run_system_image_test", |
| test = ":system_image_test", |
| )`, |
| ruleClass: "run_test_in_build", |
| loads: []BazelLoad{{ |
| file: "//build/bazel/bazel_sandwich:run_test_in_build.bzl", |
| symbols: []BazelLoadSymbol{{ |
| symbol: "run_test_in_build", |
| }}, |
| }}, |
| }) |
| } |
| |
| var allPartitionTypes = []string{ |
| "system", |
| "vendor", |
| "cache", |
| "userdata", |
| "product", |
| "system_ext", |
| "oem", |
| "odm", |
| "vendor_dlkm", |
| "odm_dlkm", |
| "system_dlkm", |
| } |
| |
| // An equivalent of make's generate-image-prop-dictionary function |
| func generateImagePropDictionary(variables *android.PartitionVariables, partitionType string) map[string]string { |
| partitionQualifiedVariables, ok := variables.PartitionQualifiedVariables[partitionType] |
| if !ok { |
| panic("Unknown partitionType: " + partitionType) |
| } |
| ret := map[string]string{} |
| if partitionType == "system" { |
| if len(variables.PartitionQualifiedVariables["system_other"].BoardPartitionSize) > 0 { |
| ret["system_other_size"] = variables.PartitionQualifiedVariables["system_other"].BoardPartitionSize |
| } |
| if len(partitionQualifiedVariables.ProductHeadroom) > 0 { |
| ret["system_headroom"] = partitionQualifiedVariables.ProductHeadroom |
| } |
| addCommonRoFlagsToImageProps(variables, partitionType, ret) |
| } |
| // TODO: other partition-specific logic |
| if variables.TargetUserimagesUseExt2 { |
| ret["fs_type"] = "ext2" |
| } else if variables.TargetUserimagesUseExt3 { |
| ret["fs_type"] = "ext3" |
| } else if variables.TargetUserimagesUseExt4 { |
| ret["fs_type"] = "ext4" |
| } |
| |
| if !variables.TargetUserimagesSparseExtDisabled { |
| ret["extfs_sparse_flag"] = "-s" |
| } |
| if !variables.TargetUserimagesSparseErofsDisabled { |
| ret["erofs_sparse_flag"] = "-s" |
| } |
| if !variables.TargetUserimagesSparseSquashfsDisabled { |
| ret["squashfs_sparse_flag"] = "-s" |
| } |
| if !variables.TargetUserimagesSparseF2fsDisabled { |
| ret["f2fs_sparse_flag"] = "-S" |
| } |
| erofsCompressor := variables.BoardErofsCompressor |
| if len(erofsCompressor) == 0 && hasErofsPartition(variables) { |
| if len(variables.BoardErofsUseLegacyCompression) > 0 { |
| erofsCompressor = "lz4" |
| } else { |
| erofsCompressor = "lz4hc,9" |
| } |
| } |
| if len(erofsCompressor) > 0 { |
| ret["erofs_default_compressor"] = erofsCompressor |
| } |
| if len(variables.BoardErofsCompressorHints) > 0 { |
| ret["erofs_default_compress_hints"] = variables.BoardErofsCompressorHints |
| } |
| if len(variables.BoardErofsCompressorHints) > 0 { |
| ret["erofs_default_compress_hints"] = variables.BoardErofsCompressorHints |
| } |
| if len(variables.BoardErofsPclusterSize) > 0 { |
| ret["erofs_pcluster_size"] = variables.BoardErofsPclusterSize |
| } |
| if len(variables.BoardErofsShareDupBlocks) > 0 { |
| ret["erofs_share_dup_blocks"] = variables.BoardErofsShareDupBlocks |
| } |
| if len(variables.BoardErofsUseLegacyCompression) > 0 { |
| ret["erofs_use_legacy_compression"] = variables.BoardErofsUseLegacyCompression |
| } |
| if len(variables.BoardExt4ShareDupBlocks) > 0 { |
| ret["ext4_share_dup_blocks"] = variables.BoardExt4ShareDupBlocks |
| } |
| if len(variables.BoardFlashLogicalBlockSize) > 0 { |
| ret["flash_logical_block_size"] = variables.BoardFlashLogicalBlockSize |
| } |
| if len(variables.BoardFlashEraseBlockSize) > 0 { |
| ret["flash_erase_block_size"] = variables.BoardFlashEraseBlockSize |
| } |
| if len(variables.BoardExt4ShareDupBlocks) > 0 { |
| ret["ext4_share_dup_blocks"] = variables.BoardExt4ShareDupBlocks |
| } |
| if len(variables.BoardExt4ShareDupBlocks) > 0 { |
| ret["ext4_share_dup_blocks"] = variables.BoardExt4ShareDupBlocks |
| } |
| for _, partitionType := range allPartitionTypes { |
| if qualifiedVariables, ok := variables.PartitionQualifiedVariables[partitionType]; ok && len(qualifiedVariables.ProductVerityPartition) > 0 { |
| ret[partitionType+"_verity_block_device"] = qualifiedVariables.ProductVerityPartition |
| } |
| } |
| // TODO: Vboot |
| // TODO: AVB |
| if variables.BoardUsesRecoveryAsBoot { |
| ret["recovery_as_boot"] = "true" |
| } |
| if variables.BoardBuildGkiBootImageWithoutRamdisk { |
| ret["gki_boot_image_without_ramdisk"] = "true" |
| } |
| if variables.ProductUseDynamicPartitionSize { |
| ret["use_dynamic_partition_size"] = "true" |
| } |
| if variables.CopyImagesForTargetFilesZip { |
| ret["use_fixed_timestamp"] = "true" |
| } |
| return ret |
| } |
| |
| // Soong equivalent of make's add-common-ro-flags-to-image-props |
| func addCommonRoFlagsToImageProps(variables *android.PartitionVariables, partitionType string, ret map[string]string) { |
| partitionQualifiedVariables, ok := variables.PartitionQualifiedVariables[partitionType] |
| if !ok { |
| panic("Unknown partitionType: " + partitionType) |
| } |
| if len(partitionQualifiedVariables.BoardErofsCompressor) > 0 { |
| ret[partitionType+"_erofs_compressor"] = partitionQualifiedVariables.BoardErofsCompressor |
| } |
| if len(partitionQualifiedVariables.BoardErofsCompressHints) > 0 { |
| ret[partitionType+"_erofs_compress_hints"] = partitionQualifiedVariables.BoardErofsCompressHints |
| } |
| if len(partitionQualifiedVariables.BoardErofsPclusterSize) > 0 { |
| ret[partitionType+"_erofs_pcluster_size"] = partitionQualifiedVariables.BoardErofsPclusterSize |
| } |
| if len(partitionQualifiedVariables.BoardExtfsRsvPct) > 0 { |
| ret[partitionType+"_extfs_rsv_pct"] = partitionQualifiedVariables.BoardExtfsRsvPct |
| } |
| if len(partitionQualifiedVariables.BoardF2fsSloadCompressFlags) > 0 { |
| ret[partitionType+"_f2fs_sldc_flags"] = partitionQualifiedVariables.BoardF2fsSloadCompressFlags |
| } |
| if len(partitionQualifiedVariables.BoardFileSystemCompress) > 0 { |
| ret[partitionType+"_f2fs_compress"] = partitionQualifiedVariables.BoardFileSystemCompress |
| } |
| if len(partitionQualifiedVariables.BoardFileSystemType) > 0 { |
| ret[partitionType+"_fs_type"] = partitionQualifiedVariables.BoardFileSystemType |
| } |
| if len(partitionQualifiedVariables.BoardJournalSize) > 0 { |
| ret[partitionType+"_journal_size"] = partitionQualifiedVariables.BoardJournalSize |
| } |
| if len(partitionQualifiedVariables.BoardPartitionReservedSize) > 0 { |
| ret[partitionType+"_reserved_size"] = partitionQualifiedVariables.BoardPartitionReservedSize |
| } |
| if len(partitionQualifiedVariables.BoardPartitionSize) > 0 { |
| ret[partitionType+"_size"] = partitionQualifiedVariables.BoardPartitionSize |
| } |
| if len(partitionQualifiedVariables.BoardSquashfsBlockSize) > 0 { |
| ret[partitionType+"_squashfs_block_size"] = partitionQualifiedVariables.BoardSquashfsBlockSize |
| } |
| if len(partitionQualifiedVariables.BoardSquashfsCompressor) > 0 { |
| ret[partitionType+"_squashfs_compressor"] = partitionQualifiedVariables.BoardSquashfsCompressor |
| } |
| if len(partitionQualifiedVariables.BoardSquashfsCompressorOpt) > 0 { |
| ret[partitionType+"_squashfs_compressor_opt"] = partitionQualifiedVariables.BoardSquashfsCompressorOpt |
| } |
| if len(partitionQualifiedVariables.BoardSquashfsDisable4kAlign) > 0 { |
| ret[partitionType+"_squashfs_disable_4k_align"] = partitionQualifiedVariables.BoardSquashfsDisable4kAlign |
| } |
| if len(partitionQualifiedVariables.BoardPartitionSize) == 0 && len(partitionQualifiedVariables.BoardPartitionReservedSize) == 0 && len(partitionQualifiedVariables.ProductHeadroom) == 0 { |
| ret[partitionType+"_disable_sparse"] = "true" |
| } |
| addCommonFlagsToImageProps(variables, partitionType, ret) |
| } |
| |
| func hasErofsPartition(variables *android.PartitionVariables) bool { |
| return variables.PartitionQualifiedVariables["product"].BoardFileSystemType == "erofs" || |
| variables.PartitionQualifiedVariables["system_ext"].BoardFileSystemType == "erofs" || |
| variables.PartitionQualifiedVariables["odm"].BoardFileSystemType == "erofs" || |
| variables.PartitionQualifiedVariables["vendor"].BoardFileSystemType == "erofs" || |
| variables.PartitionQualifiedVariables["system"].BoardFileSystemType == "erofs" || |
| variables.PartitionQualifiedVariables["vendor_dlkm"].BoardFileSystemType == "erofs" || |
| variables.PartitionQualifiedVariables["odm_dlkm"].BoardFileSystemType == "erofs" || |
| variables.PartitionQualifiedVariables["system_dlkm"].BoardFileSystemType == "erofs" |
| } |
| |
| // Soong equivalent of make's add-common-flags-to-image-props |
| func addCommonFlagsToImageProps(variables *android.PartitionVariables, partitionType string, ret map[string]string) { |
| // The selinux_fc will be handled separately |
| partitionQualifiedVariables, ok := variables.PartitionQualifiedVariables[partitionType] |
| if !ok { |
| panic("Unknown partitionType: " + partitionType) |
| } |
| ret["building_"+partitionType+"_image"] = boolToMakeString(partitionQualifiedVariables.BuildingImage) |
| } |
| |
| func boolToMakeString(b bool) string { |
| if b { |
| return "true" |
| } |
| return "" |
| } |