From 47e918450f83fc5f2680c0a3f7d6d1209e031e7c Mon Sep 17 00:00:00 2001 From: Jihoon Kang Date: Wed, 19 Jun 2024 00:51:16 +0000 Subject: [PATCH] Move vendor and product variant generation logic from cc package to android package Although image variation generation logic has moved out of cc package to the android package, the vendor and product partition variants generation logic is still specific to cc package. Therefore, in order to create a product or vendor variant, they have to specified in `ExtraImageVariants`. In order to avoid such confusing behaviors and enforce modules to specify product and vendor installation rules, this change moves the vendor and product variant generation logic to android.ImageInterface. Test: m nothing --no-skip-soong-tests && diff contents of out/soong/Android-{product}.mk Change-Id: I9e14f3739d9dea94167ee6a91e92b2f942055aba --- android/image.go | 20 ++++++++++ apex/apex.go | 4 +- bpf/bpf.go | 11 ++++-- cc/cc.go | 4 +- cc/genrule.go | 21 +++++----- cc/image.go | 93 +++++++++++++++++++++------------------------ cc/library_stub.go | 17 ++++----- etc/prebuilt_etc.go | 8 ++++ genrule/genrule.go | 2 + rust/image.go | 28 +++++++++++--- rust/rust.go | 2 + sh/sh_binary.go | 19 ++++----- 12 files changed, 137 insertions(+), 92 deletions(-) diff --git a/android/image.go b/android/image.go index 9cad05656..c278dcdf9 100644 --- a/android/image.go +++ b/android/image.go @@ -19,6 +19,12 @@ type ImageInterface interface { // ImageMutatorBegin is called before any other method in the ImageInterface. ImageMutatorBegin(ctx BaseModuleContext) + // VendorVariantNeeded should return true if the module needs a vendor variant (installed on the vendor image). + VendorVariantNeeded(ctx BaseModuleContext) bool + + // ProductVariantNeeded should return true if the module needs a product variant (unstalled on the product image). + ProductVariantNeeded(ctx BaseModuleContext) bool + // CoreVariantNeeded should return true if the module needs a core variant (installed on the system image). CoreVariantNeeded(ctx BaseModuleContext) bool @@ -49,6 +55,14 @@ type ImageInterface interface { } const ( + // VendorVariation is the variant name used for /vendor code that does not + // compile against the VNDK. + VendorVariation string = "vendor" + + // ProductVariation is the variant name used for /product code that does not + // compile against the VNDK. + ProductVariation string = "product" + // CoreVariation is the variant used for framework-private libraries, or // SDK libraries. (which framework-private libraries can use), which // will be installed to the system image. @@ -94,6 +108,12 @@ func imageMutator(ctx BottomUpMutatorContext) { if m.RecoveryVariantNeeded(ctx) { variations = append(variations, RecoveryVariation) } + if m.VendorVariantNeeded(ctx) { + variations = append(variations, VendorVariation) + } + if m.ProductVariantNeeded(ctx) { + variations = append(variations, ProductVariation) + } extraVariations := m.ExtraImageVariations(ctx) variations = append(variations, extraVariations...) diff --git a/apex/apex.go b/apex/apex.go index c19732eb1..735ba757d 100644 --- a/apex/apex.go +++ b/apex/apex.go @@ -745,9 +745,9 @@ func (a *apexBundle) getImageVariationPair() (string, string) { prefix := android.CoreVariation if a.SocSpecific() || a.DeviceSpecific() { - prefix = cc.VendorVariation + prefix = android.VendorVariation } else if a.ProductSpecific() { - prefix = cc.ProductVariation + prefix = android.ProductVariation } return prefix, "" diff --git a/bpf/bpf.go b/bpf/bpf.go index ce00b5b24..09262e507 100644 --- a/bpf/bpf.go +++ b/bpf/bpf.go @@ -104,6 +104,14 @@ var _ android.ImageInterface = (*bpf)(nil) func (bpf *bpf) ImageMutatorBegin(ctx android.BaseModuleContext) {} +func (bpf *bpf) VendorVariantNeeded(ctx android.BaseModuleContext) bool { + return proptools.Bool(bpf.properties.Vendor) +} + +func (bpf *bpf) ProductVariantNeeded(ctx android.BaseModuleContext) bool { + return false +} + func (bpf *bpf) CoreVariantNeeded(ctx android.BaseModuleContext) bool { return !proptools.Bool(bpf.properties.Vendor) } @@ -125,9 +133,6 @@ func (bpf *bpf) RecoveryVariantNeeded(ctx android.BaseModuleContext) bool { } func (bpf *bpf) ExtraImageVariations(ctx android.BaseModuleContext) []string { - if proptools.Bool(bpf.properties.Vendor) { - return []string{"vendor"} - } return nil } diff --git a/cc/cc.go b/cc/cc.go index df0aa6d68..b6c42d672 100644 --- a/cc/cc.go +++ b/cc/cc.go @@ -361,6 +361,8 @@ type BaseProperties struct { Recovery_available *bool // Used by imageMutator, set by ImageMutatorBegin() + VendorVariantNeeded bool `blueprint:"mutated"` + ProductVariantNeeded bool `blueprint:"mutated"` CoreVariantNeeded bool `blueprint:"mutated"` RamdiskVariantNeeded bool `blueprint:"mutated"` VendorRamdiskVariantNeeded bool `blueprint:"mutated"` @@ -2509,7 +2511,7 @@ func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) { if c.ImageVariation().Variation == android.CoreVariation && c.Device() && c.Target().NativeBridge == android.NativeBridgeDisabled { actx.AddVariationDependencies( - []blueprint.Variation{{Mutator: "image", Variation: VendorVariation}}, + []blueprint.Variation{{Mutator: "image", Variation: android.VendorVariation}}, llndkHeaderLibTag, deps.LlndkHeaderLibs...) } diff --git a/cc/genrule.go b/cc/genrule.go index cabf7875b..fe3b127ea 100644 --- a/cc/genrule.go +++ b/cc/genrule.go @@ -79,6 +79,14 @@ var _ android.ImageInterface = (*GenruleExtraProperties)(nil) func (g *GenruleExtraProperties) ImageMutatorBegin(ctx android.BaseModuleContext) {} +func (g *GenruleExtraProperties) VendorVariantNeeded(ctx android.BaseModuleContext) bool { + return Bool(g.Vendor_available) || Bool(g.Odm_available) || ctx.SocSpecific() || ctx.DeviceSpecific() +} + +func (g *GenruleExtraProperties) ProductVariantNeeded(ctx android.BaseModuleContext) bool { + return Bool(g.Product_available) || ctx.ProductSpecific() +} + func (g *GenruleExtraProperties) CoreVariantNeeded(ctx android.BaseModuleContext) bool { return !(ctx.SocSpecific() || ctx.DeviceSpecific() || ctx.ProductSpecific()) } @@ -102,18 +110,7 @@ func (g *GenruleExtraProperties) RecoveryVariantNeeded(ctx android.BaseModuleCon } func (g *GenruleExtraProperties) ExtraImageVariations(ctx android.BaseModuleContext) []string { - var variants []string - vendorVariantRequired := Bool(g.Vendor_available) || Bool(g.Odm_available) || ctx.SocSpecific() || ctx.DeviceSpecific() - productVariantRequired := Bool(g.Product_available) || ctx.ProductSpecific() - - if vendorVariantRequired { - variants = append(variants, VendorVariation) - } - if productVariantRequired { - variants = append(variants, ProductVariation) - } - - return variants + return nil } func (g *GenruleExtraProperties) SetImageVariation(ctx android.BaseModuleContext, variation string) { diff --git a/cc/image.go b/cc/image.go index 48a9174e3..2e52ccc63 100644 --- a/cc/image.go +++ b/cc/image.go @@ -39,18 +39,10 @@ const ( ) const ( - // VendorVariation is the variant name used for /vendor code that does not - // compile against the VNDK. - VendorVariation = "vendor" - // VendorVariationPrefix is the variant prefix used for /vendor code that compiles // against the VNDK. VendorVariationPrefix = "vendor." - // ProductVariation is the variant name used for /product code that does not - // compile against the VNDK. - ProductVariation = "product" - // ProductVariationPrefix is the variant prefix used for /product code that compiles // against the VNDK. ProductVariationPrefix = "product." @@ -117,12 +109,12 @@ func (c *Module) HasNonSystemVariants() bool { // Returns true if the module is "product" variant. Usually these modules are installed in /product func (c *Module) InProduct() bool { - return c.Properties.ImageVariation == ProductVariation + return c.Properties.ImageVariation == android.ProductVariation } // Returns true if the module is "vendor" variant. Usually these modules are installed in /vendor func (c *Module) InVendor() bool { - return c.Properties.ImageVariation == VendorVariation + return c.Properties.ImageVariation == android.VendorVariation } // Returns true if the module is "vendor" or "product" variant. This replaces previous UseVndk usages @@ -207,6 +199,12 @@ type ImageMutatableModule interface { // SetCoreVariantNeeded sets whether the Core Variant is needed. SetCoreVariantNeeded(b bool) + + // SetProductVariantNeeded sets whether the Product Variant is needed. + SetProductVariantNeeded(b bool) + + // SetVendorVariantNeeded sets whether the Vendor Variant is needed. + SetVendorVariantNeeded(b bool) } var _ ImageMutatableModule = (*Module)(nil) @@ -267,6 +265,14 @@ func (m *Module) SetCoreVariantNeeded(b bool) { m.Properties.CoreVariantNeeded = b } +func (m *Module) SetProductVariantNeeded(b bool) { + m.Properties.ProductVariantNeeded = b +} + +func (m *Module) SetVendorVariantNeeded(b bool) { + m.Properties.VendorVariantNeeded = b +} + func (m *Module) SnapshotVersion(mctx android.BaseModuleContext) string { if snapshot, ok := m.linker.(SnapshotInterface); ok { return snapshot.Version() @@ -319,41 +325,34 @@ func MutateImage(mctx android.BaseModuleContext, m ImageMutatableModule) { } } + var vendorVariantNeeded bool = false + var productVariantNeeded bool = false var coreVariantNeeded bool = false var ramdiskVariantNeeded bool = false var vendorRamdiskVariantNeeded bool = false var recoveryVariantNeeded bool = false - var vendorVariants []string - var productVariants []string - - needVndkVersionVendorVariantForLlndk := false - if m.NeedsLlndkVariants() { // This is an LLNDK library. The implementation of the library will be on /system, // and vendor and product variants will be created with LLNDK stubs. // The LLNDK libraries need vendor variants even if there is no VNDK. coreVariantNeeded = true - vendorVariants = append(vendorVariants, "") - productVariants = append(productVariants, "") - // Generate vendor variants for boardVndkVersion only if the VNDK snapshot does not - // provide the LLNDK stub libraries. - if needVndkVersionVendorVariantForLlndk { - vendorVariants = append(vendorVariants, "") - } + vendorVariantNeeded = true + productVariantNeeded = true + } else if m.NeedsVendorPublicLibraryVariants() { // A vendor public library has the implementation on /vendor, with stub variants // for system and product. coreVariantNeeded = true - vendorVariants = append(vendorVariants, "") - productVariants = append(productVariants, "") + vendorVariantNeeded = true + productVariantNeeded = true } else if m.IsSnapshotPrebuilt() { // Make vendor variants only for the versions in BOARD_VNDK_VERSION and // PRODUCT_EXTRA_VNDK_VERSIONS. if m.InstallInRecovery() { recoveryVariantNeeded = true } else { - vendorVariants = append(vendorVariants, m.SnapshotVersion(mctx)) + m.AppendExtraVariant(VendorVariationPrefix + m.SnapshotVersion(mctx)) } } else if m.HasNonSystemVariants() { // This will be available to /system unless it is product_specific @@ -364,16 +363,16 @@ func MutateImage(mctx android.BaseModuleContext, m ImageMutatableModule) { // BOARD_VNDK_VERSION. The other modules are regarded as AOSP, or // PLATFORM_VNDK_VERSION. if m.HasVendorVariant() { - vendorVariants = append(vendorVariants, "") + vendorVariantNeeded = true } // product_available modules are available to /product. if m.HasProductVariant() { - productVariants = append(productVariants, "") + productVariantNeeded = true } } else if vendorSpecific && m.SdkVersion() == "" { // This will be available in /vendor (or /odm) only - vendorVariants = append(vendorVariants, "") + vendorVariantNeeded = true } else { // This is either in /system (or similar: /data), or is a // module built with the NDK. Modules built with the NDK @@ -384,7 +383,7 @@ func MutateImage(mctx android.BaseModuleContext, m ImageMutatableModule) { if coreVariantNeeded && productSpecific && m.SdkVersion() == "" { // The module has "product_specific: true" that does not create core variant. coreVariantNeeded = false - productVariants = append(productVariants, "") + productVariantNeeded = true } if m.RamdiskAvailable() { @@ -414,36 +413,32 @@ func MutateImage(mctx android.BaseModuleContext, m ImageMutatableModule) { coreVariantNeeded = false } - for _, variant := range android.FirstUniqueStrings(vendorVariants) { - if variant == "" { - m.AppendExtraVariant(VendorVariation) - } else { - m.AppendExtraVariant(VendorVariationPrefix + variant) - } - } - - for _, variant := range android.FirstUniqueStrings(productVariants) { - if variant == "" { - m.AppendExtraVariant(ProductVariation) - } else { - m.AppendExtraVariant(ProductVariationPrefix + variant) - } - } - m.SetRamdiskVariantNeeded(ramdiskVariantNeeded) m.SetVendorRamdiskVariantNeeded(vendorRamdiskVariantNeeded) m.SetRecoveryVariantNeeded(recoveryVariantNeeded) m.SetCoreVariantNeeded(coreVariantNeeded) + m.SetProductVariantNeeded(productVariantNeeded) + m.SetVendorVariantNeeded(vendorVariantNeeded) // Disable the module if no variants are needed. if !ramdiskVariantNeeded && !recoveryVariantNeeded && !coreVariantNeeded && + !productVariantNeeded && + !vendorVariantNeeded && len(m.ExtraVariants()) == 0 { m.Disable() } } +func (c *Module) VendorVariantNeeded(ctx android.BaseModuleContext) bool { + return c.Properties.VendorVariantNeeded +} + +func (c *Module) ProductVariantNeeded(ctx android.BaseModuleContext) bool { + return c.Properties.ProductVariantNeeded +} + func (c *Module) CoreVariantNeeded(ctx android.BaseModuleContext) bool { return c.Properties.CoreVariantNeeded } @@ -537,15 +532,15 @@ func (c *Module) SetImageVariation(ctx android.BaseModuleContext, variant string } else if variant == android.RecoveryVariation { c.MakeAsPlatform() squashRecoverySrcs(c) - } else if strings.HasPrefix(variant, VendorVariation) { - c.Properties.ImageVariation = VendorVariation + } else if strings.HasPrefix(variant, android.VendorVariation) { + c.Properties.ImageVariation = android.VendorVariation if strings.HasPrefix(variant, VendorVariationPrefix) { c.Properties.VndkVersion = strings.TrimPrefix(variant, VendorVariationPrefix) } squashVendorSrcs(c) - } else if strings.HasPrefix(variant, ProductVariation) { - c.Properties.ImageVariation = ProductVariation + } else if strings.HasPrefix(variant, android.ProductVariation) { + c.Properties.ImageVariation = android.ProductVariation if strings.HasPrefix(variant, ProductVariationPrefix) { c.Properties.VndkVersion = strings.TrimPrefix(variant, ProductVariationPrefix) } diff --git a/cc/library_stub.go b/cc/library_stub.go index 9643ec2a1..6f06333ac 100644 --- a/cc/library_stub.go +++ b/cc/library_stub.go @@ -494,6 +494,12 @@ func BuildApiVariantName(baseName string, variant string, version string) string // Implement ImageInterface to generate image variants func (v *CcApiVariant) ImageMutatorBegin(ctx android.BaseModuleContext) {} +func (v *CcApiVariant) VendorVariantNeeded(ctx android.BaseModuleContext) bool { + return String(v.properties.Variant) == "llndk" +} +func (v *CcApiVariant) ProductVariantNeeded(ctx android.BaseModuleContext) bool { + return String(v.properties.Variant) == "llndk" +} func (v *CcApiVariant) CoreVariantNeeded(ctx android.BaseModuleContext) bool { return inList(String(v.properties.Variant), []string{"ndk", "apex"}) } @@ -501,15 +507,6 @@ func (v *CcApiVariant) RamdiskVariantNeeded(ctx android.BaseModuleContext) bool func (v *CcApiVariant) VendorRamdiskVariantNeeded(ctx android.BaseModuleContext) bool { return false } func (v *CcApiVariant) DebugRamdiskVariantNeeded(ctx android.BaseModuleContext) bool { return false } func (v *CcApiVariant) RecoveryVariantNeeded(ctx android.BaseModuleContext) bool { return false } -func (v *CcApiVariant) ExtraImageVariations(ctx android.BaseModuleContext) []string { - var variations []string - - if String(v.properties.Variant) == "llndk" { - variations = append(variations, VendorVariation) - variations = append(variations, ProductVariation) - } - - return variations -} +func (v *CcApiVariant) ExtraImageVariations(ctx android.BaseModuleContext) []string { return nil } func (v *CcApiVariant) SetImageVariation(ctx android.BaseModuleContext, variation string) { } diff --git a/etc/prebuilt_etc.go b/etc/prebuilt_etc.go index 207548894..5a4818f4f 100644 --- a/etc/prebuilt_etc.go +++ b/etc/prebuilt_etc.go @@ -216,6 +216,14 @@ var _ android.ImageInterface = (*PrebuiltEtc)(nil) func (p *PrebuiltEtc) ImageMutatorBegin(ctx android.BaseModuleContext) {} +func (p *PrebuiltEtc) VendorVariantNeeded(ctx android.BaseModuleContext) bool { + return false +} + +func (p *PrebuiltEtc) ProductVariantNeeded(ctx android.BaseModuleContext) bool { + return false +} + func (p *PrebuiltEtc) CoreVariantNeeded(ctx android.BaseModuleContext) bool { return !p.ModuleBase.InstallInRecovery() && !p.ModuleBase.InstallInRamdisk() && !p.ModuleBase.InstallInVendorRamdisk() && !p.ModuleBase.InstallInDebugRamdisk() diff --git a/genrule/genrule.go b/genrule/genrule.go index b23530369..c0942d3f1 100644 --- a/genrule/genrule.go +++ b/genrule/genrule.go @@ -643,6 +643,8 @@ func generatorFactory(taskGenerator taskFunc, props ...interface{}) *Module { type noopImageInterface struct{} func (x noopImageInterface) ImageMutatorBegin(android.BaseModuleContext) {} +func (x noopImageInterface) VendorVariantNeeded(android.BaseModuleContext) bool { return false } +func (x noopImageInterface) ProductVariantNeeded(android.BaseModuleContext) bool { return false } func (x noopImageInterface) CoreVariantNeeded(android.BaseModuleContext) bool { return false } func (x noopImageInterface) RamdiskVariantNeeded(android.BaseModuleContext) bool { return false } func (x noopImageInterface) VendorRamdiskVariantNeeded(android.BaseModuleContext) bool { return false } diff --git a/rust/image.go b/rust/image.go index fec6d92d8..26929b1ac 100644 --- a/rust/image.go +++ b/rust/image.go @@ -77,6 +77,14 @@ func (mod *Module) SetCoreVariantNeeded(b bool) { mod.Properties.CoreVariantNeeded = b } +func (mod *Module) SetProductVariantNeeded(b bool) { + mod.Properties.ProductVariantNeeded = b +} + +func (mod *Module) SetVendorVariantNeeded(b bool) { + mod.Properties.VendorVariantNeeded = b +} + func (mod *Module) SnapshotVersion(mctx android.BaseModuleContext) string { if snapshot, ok := mod.compiler.(cc.SnapshotInterface); ok { return snapshot.Version() @@ -86,6 +94,14 @@ func (mod *Module) SnapshotVersion(mctx android.BaseModuleContext) string { } } +func (mod *Module) VendorVariantNeeded(ctx android.BaseModuleContext) bool { + return mod.Properties.VendorVariantNeeded +} + +func (mod *Module) ProductVariantNeeded(ctx android.BaseModuleContext) bool { + return mod.Properties.ProductVariantNeeded +} + func (mod *Module) VendorRamdiskVariantNeeded(ctx android.BaseModuleContext) bool { return mod.Properties.VendorRamdiskVariantNeeded } @@ -184,12 +200,12 @@ func (mod *Module) HasNonSystemVariants() bool { } func (mod *Module) InProduct() bool { - return mod.Properties.ImageVariation == cc.ProductVariation + return mod.Properties.ImageVariation == android.ProductVariation } // Returns true if the module is "vendor" variant. Usually these modules are installed in /vendor func (mod *Module) InVendor() bool { - return mod.Properties.ImageVariation == cc.VendorVariation + return mod.Properties.ImageVariation == android.VendorVariation } // Returns true if the module is "vendor" or "product" variant. @@ -202,13 +218,13 @@ func (mod *Module) SetImageVariation(ctx android.BaseModuleContext, variant stri mod.MakeAsPlatform() } else if variant == android.RecoveryVariation { mod.MakeAsPlatform() - } else if strings.HasPrefix(variant, cc.VendorVariation) { - mod.Properties.ImageVariation = cc.VendorVariation + } else if strings.HasPrefix(variant, android.VendorVariation) { + mod.Properties.ImageVariation = android.VendorVariation if strings.HasPrefix(variant, cc.VendorVariationPrefix) { mod.Properties.VndkVersion = strings.TrimPrefix(variant, cc.VendorVariationPrefix) } - } else if strings.HasPrefix(variant, cc.ProductVariation) { - mod.Properties.ImageVariation = cc.ProductVariation + } else if strings.HasPrefix(variant, android.ProductVariation) { + mod.Properties.ImageVariation = android.ProductVariation if strings.HasPrefix(variant, cc.ProductVariationPrefix) { mod.Properties.VndkVersion = strings.TrimPrefix(variant, cc.ProductVariationPrefix) } diff --git a/rust/rust.go b/rust/rust.go index 7cd9df4c7..8a053c184 100644 --- a/rust/rust.go +++ b/rust/rust.go @@ -80,6 +80,8 @@ type BaseProperties struct { RustSubName string `blueprint:"mutated"` // Set by imageMutator + ProductVariantNeeded bool `blueprint:"mutated"` + VendorVariantNeeded bool `blueprint:"mutated"` CoreVariantNeeded bool `blueprint:"mutated"` VendorRamdiskVariantNeeded bool `blueprint:"mutated"` RamdiskVariantNeeded bool `blueprint:"mutated"` diff --git a/sh/sh_binary.go b/sh/sh_binary.go index 48a442de4..2e48d83e6 100644 --- a/sh/sh_binary.go +++ b/sh/sh_binary.go @@ -212,6 +212,14 @@ var _ android.ImageInterface = (*ShBinary)(nil) func (s *ShBinary) ImageMutatorBegin(ctx android.BaseModuleContext) {} +func (s *ShBinary) VendorVariantNeeded(ctx android.BaseModuleContext) bool { + return s.InstallInVendor() +} + +func (s *ShBinary) ProductVariantNeeded(ctx android.BaseModuleContext) bool { + return s.InstallInProduct() +} + func (s *ShBinary) CoreVariantNeeded(ctx android.BaseModuleContext) bool { return !s.InstallInRecovery() && !s.InstallInRamdisk() && !s.InstallInVendorRamdisk() && !s.ModuleBase.InstallInVendor() } @@ -233,14 +241,7 @@ func (s *ShBinary) RecoveryVariantNeeded(ctx android.BaseModuleContext) bool { } func (s *ShBinary) ExtraImageVariations(ctx android.BaseModuleContext) []string { - extraVariations := []string{} - if s.InstallInProduct() { - extraVariations = append(extraVariations, cc.ProductVariation) - } - if s.InstallInVendor() { - extraVariations = append(extraVariations, cc.VendorVariation) - } - return extraVariations + return nil } func (s *ShBinary) SetImageVariation(ctx android.BaseModuleContext, variation string) { @@ -306,7 +307,7 @@ func (s *ShBinary) generateAndroidBuildActions(ctx android.ModuleContext) { func (s *ShBinary) GetSubname(ctx android.ModuleContext) string { ret := "" if s.properties.ImageVariation != "" { - if s.properties.ImageVariation != cc.VendorVariation { + if s.properties.ImageVariation != android.VendorVariation { ret = "." + s.properties.ImageVariation } }