From 380fc3615cf8c837e25dd7c480f8ce579ffd5d90 Mon Sep 17 00:00:00 2001 From: Jooyung Han Date: Fri, 13 Mar 2020 15:23:36 +0900 Subject: [PATCH] Enforce min_sdk_version of apex(use_vendor:true) Even though use_vendor:true is prohibited, there is media.swcodec apex which is still use_vendor: true and also needs to support Android10. (min_sdk_version: 29) Because LLNDK stubs were provided only for the current VNDK version, media.swcodec couldn't be built against min_sdk_version: 29. This change introduces additional versions for LLNDK stubs which are enforced when an apex with use_vendor: true sets min_sdk_version. To make things easier, the versions of LLNDK stubs are borrowed from its implementation libraries. Bug: 147450930 Bug: 149591522 Test: TARGET_BUILD_APPS=com.android.media.swcodec m (with min_sdk_version: 29 set) check if liblog/libc/libm/libdl stubs are 29 check if 29 stubs don't have new symbols. Change-Id: I79946cbb4da6617138a96d2b254349d3a298e77b --- apex/apex_test.go | 123 +++++++++++++++++++++++++++----------------- cc/cc.go | 40 +++++++++++++- cc/cc_test.go | 28 ++++++++++ cc/library.go | 45 +++++++++++----- cc/llndk_library.go | 13 +++++ cc/vndk.go | 3 ++ 6 files changed, 189 insertions(+), 63 deletions(-) diff --git a/apex/apex_test.go b/apex/apex_test.go index babc27b43..21d517fc6 100644 --- a/apex/apex_test.go +++ b/apex/apex_test.go @@ -858,58 +858,89 @@ func TestApexWithRuntimeLibsDependency(t *testing.T) { } -func TestApexDependencyToLLNDK(t *testing.T) { - ctx, _ := testApex(t, ` - apex { - name: "myapex", - key: "myapex.key", - use_vendor: true, - native_shared_libs: ["mylib"], - } +func TestApexDependsOnLLNDKTransitively(t *testing.T) { + testcases := []struct { + name string + minSdkVersion string + shouldLink string + shouldNotLink []string + }{ + { + name: "should link to test latest", + minSdkVersion: "current", + shouldLink: "30", + shouldNotLink: []string{"29"}, + }, + { + name: "should link to llndk#29", + minSdkVersion: "29", + shouldLink: "29", + shouldNotLink: []string{"30"}, + }, + } + for _, tc := range testcases { + t.Run(tc.name, func(t *testing.T) { + ctx, _ := testApex(t, ` + apex { + name: "myapex", + key: "myapex.key", + use_vendor: true, + native_shared_libs: ["mylib"], + min_sdk_version: "`+tc.minSdkVersion+`", + } - apex_key { - name: "myapex.key", - public_key: "testkey.avbpubkey", - private_key: "testkey.pem", - } + apex_key { + name: "myapex.key", + public_key: "testkey.avbpubkey", + private_key: "testkey.pem", + } - cc_library { - name: "mylib", - srcs: ["mylib.cpp"], - vendor_available: true, - shared_libs: ["libbar"], - system_shared_libs: [], - stl: "none", - apex_available: [ "myapex" ], - } + cc_library { + name: "mylib", + srcs: ["mylib.cpp"], + vendor_available: true, + shared_libs: ["libbar"], + system_shared_libs: [], + stl: "none", + apex_available: [ "myapex" ], + } - cc_library { - name: "libbar", - srcs: ["mylib.cpp"], - system_shared_libs: [], - stl: "none", - } + cc_library { + name: "libbar", + srcs: ["mylib.cpp"], + system_shared_libs: [], + stl: "none", + stubs: { versions: ["29","30"] }, + } - llndk_library { - name: "libbar", - symbol_file: "", - } - `, func(fs map[string][]byte, config android.Config) { - setUseVendorWhitelistForTest(config, []string{"myapex"}) - }) + llndk_library { + name: "libbar", + symbol_file: "", + } + `, func(fs map[string][]byte, config android.Config) { + setUseVendorWhitelistForTest(config, []string{"myapex"}) + }, withUnbundledBuild) - apexRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexRule") - copyCmds := apexRule.Args["copy_commands"] + // Ensure that LLNDK dep is not included + ensureExactContents(t, ctx, "myapex", "android_common_myapex_image", []string{ + "lib64/mylib.so", + }) - // Ensure that LLNDK dep is not included - ensureNotContains(t, copyCmds, "image.apex/lib64/libbar.so") + // Ensure that LLNDK dep is required + apexManifestRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexManifestRule") + ensureListEmpty(t, names(apexManifestRule.Args["provideNativeLibs"])) + ensureListContains(t, names(apexManifestRule.Args["requireNativeLibs"]), "libbar.so") - apexManifestRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexManifestRule") - ensureListEmpty(t, names(apexManifestRule.Args["provideNativeLibs"])) - - // Ensure that LLNDK dep is required - ensureListContains(t, names(apexManifestRule.Args["requireNativeLibs"]), "libbar.so") + mylibLdFlags := ctx.ModuleForTests("mylib", "android_vendor.VER_arm64_armv8-a_shared_myapex").Rule("ld").Args["libFlags"] + ensureContains(t, mylibLdFlags, "libbar.llndk/android_vendor.VER_arm64_armv8-a_shared_"+tc.shouldLink+"/libbar.so") + for _, ver := range tc.shouldNotLink { + ensureNotContains(t, mylibLdFlags, "libbar.llndk/android_vendor.VER_arm64_armv8-a_shared_"+ver+"/libbar.so") + } + mylibCFlags := ctx.ModuleForTests("mylib", "android_vendor.VER_arm64_armv8-a_static_myapex").Rule("cc").Args["cFlags"] + ensureContains(t, mylibCFlags, "__LIBBAR_API__="+tc.shouldLink) + }) + } } func TestApexWithSystemLibsStubs(t *testing.T) { @@ -1239,10 +1270,6 @@ func TestQTargetApexUseStaticUnwinder(t *testing.T) { // note that platform variant is not. cm = ctx.ModuleForTests("libc++", "android_arm64_armv8-a_shared").Module().(*cc.Module) ensureListNotContains(t, cm.Properties.AndroidMkStaticLibs, "libgcc_stripped") - - libFlags := ctx.ModuleForTests("libx", "android_arm64_armv8-a_shared_myapex").Rule("ld").Args["libFlags"] - ensureContains(t, libFlags, "android_arm64_armv8-a_shared_myapex/libc++.so") - ensureContains(t, libFlags, "android_arm64_armv8-a_shared_29/libc.so") // min_sdk_version applied } func TestInvalidMinSdkVersion(t *testing.T) { diff --git a/cc/cc.go b/cc/cc.go index 61ae10a02..2009d91ec 100644 --- a/cc/cc.go +++ b/cc/cc.go @@ -622,6 +622,10 @@ func (c *Module) SetBuildStubs() { c.Properties.PreventInstall = true return } + if _, ok := c.linker.(*llndkStubDecorator); ok { + c.Properties.HideFromMake = true + return + } } panic(fmt.Errorf("SetBuildStubs called on non-library module: %q", c.BaseModuleName())) } @@ -641,6 +645,10 @@ func (c *Module) SetStubsVersions(version string) { library.MutatedProperties.StubsVersion = version return } + if llndk, ok := c.linker.(*llndkStubDecorator); ok { + llndk.libraryDecorator.MutatedProperties.StubsVersion = version + return + } } panic(fmt.Errorf("SetStubsVersions called on non-library module: %q", c.BaseModuleName())) } @@ -650,6 +658,9 @@ func (c *Module) StubsVersion() string { if library, ok := c.linker.(*libraryDecorator); ok { return library.MutatedProperties.StubsVersion } + if llndk, ok := c.linker.(*llndkStubDecorator); ok { + return llndk.libraryDecorator.MutatedProperties.StubsVersion + } } panic(fmt.Errorf("StubsVersion called on non-library module: %q", c.BaseModuleName())) } @@ -1851,7 +1862,7 @@ func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) { addSharedLibDependencies := func(depTag DependencyTag, name string, version string) { var variations []blueprint.Variation variations = append(variations, blueprint.Variation{Mutator: "link", Variation: "shared"}) - versionVariantAvail := !ctx.useVndk() && !c.InRecovery() && !c.InRamdisk() + versionVariantAvail := !c.InRecovery() && !c.InRamdisk() if version != "" && versionVariantAvail { // Version is explicitly specified. i.e. libFoo#30 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version}) @@ -2186,13 +2197,17 @@ func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps { if depTag == android.ProtoPluginDepTag { return } + if depTag == llndkImplDep { + return + } if dep.Target().Os != ctx.Os() { ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName) return } if dep.Target().Arch.ArchType != ctx.Arch().ArchType { - ctx.ModuleErrorf("Arch mismatch between %q and %q", ctx.ModuleName(), depName) + ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)", + ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType) return } @@ -2287,6 +2302,27 @@ func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps { return // stop processing this dep } } + if c.UseVndk() { + if m, ok := ccDep.(*Module); ok && m.IsStubs() { // LLNDK + // by default, use current version of LLNDK + versionToUse := "" + versions := stubsVersionsFor(ctx.Config())[depName] + if c.ApexName() != "" && len(versions) > 0 { + // if this is for use_vendor apex && dep has stubsVersions + // apply the same rule of apex sdk enforcement to choose right version + var err error + useLatest := c.ShouldSupportAndroid10() && !ctx.Config().UnbundledBuild() + versionToUse, err = c.ChooseSdkVersion(versions, useLatest) + if err != nil { + ctx.OtherModuleErrorf(dep, err.Error()) + return + } + } + if versionToUse != ccDep.StubsVersion() { + return + } + } + } depPaths.IncludeDirs = append(depPaths.IncludeDirs, ccDep.IncludeDirs()...) diff --git a/cc/cc_test.go b/cc/cc_test.go index 9a9678f1d..67eb248d2 100644 --- a/cc/cc_test.go +++ b/cc/cc_test.go @@ -2398,6 +2398,34 @@ func checkEquals(t *testing.T, message string, expected, actual interface{}) { } } +func TestLlndkLibrary(t *testing.T) { + ctx := testCc(t, ` + cc_library { + name: "libllndk", + stubs: { versions: ["1", "2"] }, + } + llndk_library { + name: "libllndk", + } + `) + actual := ctx.ModuleVariantsForTests("libllndk.llndk") + expected := []string{ + "android_vendor.VER_arm64_armv8-a_shared", + "android_vendor.VER_arm64_armv8-a_shared_1", + "android_vendor.VER_arm64_armv8-a_shared_2", + "android_vendor.VER_arm_armv7-a-neon_shared", + "android_vendor.VER_arm_armv7-a-neon_shared_1", + "android_vendor.VER_arm_armv7-a-neon_shared_2", + } + checkEquals(t, "variants for llndk stubs", expected, actual) + + params := ctx.ModuleForTests("libllndk.llndk", "android_vendor.VER_arm_armv7-a-neon_shared").Description("generate stub") + checkEquals(t, "use VNDK version for default stubs", "current", params.Args["apiLevel"]) + + params = ctx.ModuleForTests("libllndk.llndk", "android_vendor.VER_arm_armv7-a-neon_shared_1").Description("generate stub") + checkEquals(t, "override apiLevel for versioned stubs", "1", params.Args["apiLevel"]) +} + func TestLlndkHeaders(t *testing.T) { ctx := testCc(t, ` llndk_headers { diff --git a/cc/library.go b/cc/library.go index 335b18e18..7d3bdc218 100644 --- a/cc/library.go +++ b/cc/library.go @@ -1486,6 +1486,19 @@ func checkVersions(ctx android.BaseModuleContext, versions []string) { } } +func createVersionVariations(mctx android.BottomUpMutatorContext, versions []string) { + // "" is for the non-stubs variant + versions = append([]string{""}, versions...) + + modules := mctx.CreateVariations(versions...) + for i, m := range modules { + if versions[i] != "" { + m.(LinkableInterface).SetBuildStubs() + m.(LinkableInterface).SetStubsVersions(versions[i]) + } + } +} + // Version mutator splits a module into the mandatory non-stubs variant // (which is unnamed) and zero or more stubs variants. func VersionMutator(mctx android.BottomUpMutatorContext) { @@ -1497,24 +1510,30 @@ func VersionMutator(mctx android.BottomUpMutatorContext) { return } - // save the list of versions for later use stubsVersionsLock.Lock() defer stubsVersionsLock.Unlock() + // save the list of versions for later use stubsVersionsFor(mctx.Config())[mctx.ModuleName()] = versions - // "" is for the non-stubs variant - versions = append([]string{""}, versions...) - - modules := mctx.CreateVariations(versions...) - for i, m := range modules { - if versions[i] != "" { - m.(LinkableInterface).SetBuildStubs() - m.(LinkableInterface).SetStubsVersions(versions[i]) - } - } - } else { - mctx.CreateVariations("") + createVersionVariations(mctx, versions) + return } + + if c, ok := library.(*Module); ok && c.IsStubs() { + stubsVersionsLock.Lock() + defer stubsVersionsLock.Unlock() + // For LLNDK llndk_library, we borrow vstubs.ersions from its implementation library. + // Since llndk_library has dependency to its implementation library, + // we can safely access stubsVersionsFor() with its baseModuleName. + versions := stubsVersionsFor(mctx.Config())[c.BaseModuleName()] + // save the list of versions for later use + stubsVersionsFor(mctx.Config())[mctx.ModuleName()] = versions + + createVersionVariations(mctx, versions) + return + } + + mctx.CreateVariations("") return } if genrule, ok := mctx.Module().(*genrule.Module); ok { diff --git a/cc/llndk_library.go b/cc/llndk_library.go index 3dee6920a..09050aa34 100644 --- a/cc/llndk_library.go +++ b/cc/llndk_library.go @@ -19,8 +19,14 @@ import ( "strings" "android/soong/android" + + "github.com/google/blueprint" ) +var llndkImplDep = struct { + blueprint.DependencyTag +}{} + var ( llndkLibrarySuffix = ".llndk" llndkHeadersSuffix = ".llndk" @@ -81,6 +87,9 @@ func (stub *llndkStubDecorator) compile(ctx ModuleContext, flags Flags, deps Pat // For non-enforcing devices, vndkVer is empty. Use "current" in that case, too. vndkVer = "current" } + if stub.stubsVersion() != "" { + vndkVer = stub.stubsVersion() + } objs, versionScript := compileStubLibrary(ctx, flags, String(stub.Properties.Symbol_file), vndkVer, "--llndk") stub.versionScriptPath = versionScript return objs @@ -154,6 +163,10 @@ func (stub *llndkStubDecorator) link(ctx ModuleContext, flags Flags, deps PathDe stub.libraryDecorator.flagExporter.Properties.Export_include_dirs = []string{} } + if stub.stubsVersion() != "" { + stub.reexportFlags("-D" + versioningMacroName(ctx.baseModuleName()) + "=" + stub.stubsVersion()) + } + return stub.libraryDecorator.link(ctx, flags, deps, objs) } diff --git a/cc/vndk.go b/cc/vndk.go index e02e7b534..4888dcf07 100644 --- a/cc/vndk.go +++ b/cc/vndk.go @@ -297,6 +297,9 @@ func processLlndkLibrary(mctx android.BottomUpMutatorContext, m *Module) { if !Bool(lib.Properties.Vendor_available) { vndkPrivateLibraries(mctx.Config())[name] = filename } + if mctx.OtherModuleExists(name) { + mctx.AddFarVariationDependencies(m.Target().Variations(), llndkImplDep, name) + } } func processVndkLibrary(mctx android.BottomUpMutatorContext, m *Module) {