diff --git a/java/androidmk.go b/java/androidmk.go index a4dac80d4..d90e6df6b 100644 --- a/java/androidmk.go +++ b/java/androidmk.go @@ -133,13 +133,19 @@ func (library *Library) AndroidMkEntries() []android.AndroidMkEntries { return entriesList } -func (j *JavaFuzzLibrary) AndroidMkEntries() []android.AndroidMkEntries { +func (j *JavaFuzzTest) AndroidMkEntries() []android.AndroidMkEntries { entriesList := j.Library.AndroidMkEntries() entries := &entriesList[0] entries.ExtraEntries = append(entries.ExtraEntries, func(ctx android.AndroidMkExtraEntriesContext, entries *android.AndroidMkEntries) { entries.AddStrings("LOCAL_COMPATIBILITY_SUITE", "null-suite") - androidMkWriteTestData(j.jniFilePaths, entries) androidMkWriteTestData(android.Paths{j.implementationJarFile}, entries) + androidMkWriteTestData(j.jniFilePaths, entries) + if j.fuzzPackagedModule.Corpus != nil { + androidMkWriteTestData(j.fuzzPackagedModule.Corpus, entries) + } + if j.fuzzPackagedModule.Dictionary != nil { + androidMkWriteTestData(android.Paths{j.fuzzPackagedModule.Dictionary}, entries) + } }) return entriesList } diff --git a/java/fuzz.go b/java/fuzz.go index 1d6b91346..2b9e22b8e 100644 --- a/java/fuzz.go +++ b/java/fuzz.go @@ -19,12 +19,12 @@ import ( "sort" "strings" - "github.com/google/blueprint" - "github.com/google/blueprint/proptools" - "android/soong/android" "android/soong/cc" "android/soong/fuzz" + + "github.com/google/blueprint" + "github.com/google/blueprint/proptools" ) const ( @@ -32,63 +32,63 @@ const ( targetString = "target" ) -type jniProperties struct { - // list of jni libs - Jni_libs []string - - // sanitization - Sanitizers []string -} - func init() { RegisterJavaFuzzBuildComponents(android.InitRegistrationContext) } func RegisterJavaFuzzBuildComponents(ctx android.RegistrationContext) { ctx.RegisterModuleType("java_fuzz", JavaFuzzFactory) - ctx.RegisterModuleType("java_fuzz_host", JavaFuzzHostFactory) - ctx.RegisterSingletonType("java_fuzz_host_packaging", javaFuzzHostPackagingFactory) - ctx.RegisterSingletonType("java_fuzz_device_packaging", javaFuzzDevicePackagingFactory) + ctx.RegisterSingletonType("java_fuzz_packaging", javaFuzzPackagingFactory) } -type JavaFuzzLibrary struct { - Library +type JavaFuzzTest struct { + Test fuzzPackagedModule fuzz.FuzzPackagedModule - jniProperties jniProperties jniFilePaths android.Paths } -// IsSanitizerEnabledForJni implemented to make JavaFuzzLibrary implement -// cc.JniSanitizeable. It returns a bool for whether a cc dependency should be -// sanitized for the given sanitizer or not. -func (j *JavaFuzzLibrary) IsSanitizerEnabledForJni(ctx android.BaseModuleContext, sanitizerName string) bool { - // TODO: once b/231370928 is resolved, please uncomment the loop - // for _, s := range j.jniProperties.Sanitizers { - // if sanitizerName == s { - // return true - // } - // } - return false +// java_fuzz builds and links sources into a `.jar` file for the device. +// This generates .class files in a jar which can then be instrumented before +// fuzzing in Android Runtime (ART: Android OS on emulator or device) +func JavaFuzzFactory() android.Module { + module := &JavaFuzzTest{} + + module.addHostAndDeviceProperties() + module.AddProperties(&module.testProperties) + module.AddProperties(&module.fuzzPackagedModule.FuzzProperties) + + module.Module.properties.Installable = proptools.BoolPtr(true) + module.Module.dexpreopter.isTest = true + module.Module.linter.properties.Lint.Test = proptools.BoolPtr(true) + + android.AddLoadHook(module, func(ctx android.LoadHookContext) { + disableLinuxBionic := struct { + Target struct { + Linux_bionic struct { + Enabled *bool + } + } + }{} + disableLinuxBionic.Target.Linux_bionic.Enabled = proptools.BoolPtr(false) + ctx.AppendProperties(&disableLinuxBionic) + }) + + InitJavaModuleMultiTargets(module, android.HostAndDeviceSupported) + return module } -func (j *JavaFuzzLibrary) DepsMutator(mctx android.BottomUpMutatorContext) { - if len(j.jniProperties.Jni_libs) > 0 { - if j.fuzzPackagedModule.FuzzProperties.Fuzz_config == nil { - config := &fuzz.FuzzConfig{} - j.fuzzPackagedModule.FuzzProperties.Fuzz_config = config - } - // this will be used by the ingestion pipeline to determine the version - // of jazzer to add to the fuzzer package - j.fuzzPackagedModule.FuzzProperties.Fuzz_config.IsJni = proptools.BoolPtr(true) - for _, target := range mctx.MultiTargets() { +func (j *JavaFuzzTest) DepsMutator(ctx android.BottomUpMutatorContext) { + if len(j.testProperties.Jni_libs) > 0 { + for _, target := range ctx.MultiTargets() { sharedLibVariations := append(target.Variations(), blueprint.Variation{Mutator: "link", Variation: "shared"}) - mctx.AddFarVariationDependencies(sharedLibVariations, cc.JniFuzzLibTag, j.jniProperties.Jni_libs...) + ctx.AddFarVariationDependencies(sharedLibVariations, jniLibTag, j.testProperties.Jni_libs...) } } - j.Library.DepsMutator(mctx) + + j.deps(ctx) } -func (j *JavaFuzzLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) { +func (j *JavaFuzzTest) GenerateAndroidBuildActions(ctx android.ModuleContext) { if j.fuzzPackagedModule.FuzzProperties.Corpus != nil { j.fuzzPackagedModule.Corpus = android.PathsForModuleSrc(ctx, j.fuzzPackagedModule.FuzzProperties.Corpus) } @@ -105,21 +105,15 @@ func (j *JavaFuzzLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) } _, sharedDeps := cc.CollectAllSharedDependencies(ctx) - for _, dep := range sharedDeps { sharedLibInfo := ctx.OtherModuleProvider(dep, cc.SharedLibraryInfoProvider).(cc.SharedLibraryInfo) if sharedLibInfo.SharedLibrary != nil { - // The .class jars are output in slightly different locations - // relative to the jni libs. Therefore, for consistency across - // host and device fuzzers of jni lib location, we save it in a - // native_libs directory. - var relPath string + arch := "lib" if sharedLibInfo.Target.Arch.ArchType.Multilib == "lib64" { - relPath = filepath.Join("lib64", sharedLibInfo.SharedLibrary.Base()) - } else { - relPath = filepath.Join("lib", sharedLibInfo.SharedLibrary.Base()) + arch = "lib64" } - libPath := android.PathForModuleOut(ctx, relPath) + + libPath := android.PathForModuleOut(ctx, filepath.Join(arch, sharedLibInfo.SharedLibrary.Base())) ctx.Build(pctx, android.BuildParams{ Rule: android.Cp, Input: sharedLibInfo.SharedLibrary, @@ -129,104 +123,35 @@ func (j *JavaFuzzLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) } else { ctx.PropertyErrorf("jni_libs", "%q of type %q is not supported", dep.Name(), ctx.OtherModuleType(dep)) } + } - j.Library.GenerateAndroidBuildActions(ctx) + j.Test.GenerateAndroidBuildActions(ctx) } -// java_fuzz_host builds and links sources into a `.jar` file for the host. -// -// By default, a java_fuzz produces a `.jar` file containing `.class` files. -// This jar is not suitable for installing on a device. -func JavaFuzzHostFactory() android.Module { - module := &JavaFuzzLibrary{} - module.addHostProperties() - module.AddProperties(&module.jniProperties) - module.Module.properties.Installable = proptools.BoolPtr(true) - module.AddProperties(&module.fuzzPackagedModule.FuzzProperties) - - // java_fuzz packaging rules collide when both linux_glibc and linux_bionic are enabled, disable the linux_bionic variants. - android.AddLoadHook(module, func(ctx android.LoadHookContext) { - disableLinuxBionic := struct { - Target struct { - Linux_bionic struct { - Enabled *bool - } - } - }{} - disableLinuxBionic.Target.Linux_bionic.Enabled = proptools.BoolPtr(false) - ctx.AppendProperties(&disableLinuxBionic) - }) - - InitJavaModuleMultiTargets(module, android.HostSupportedNoCross) - return module -} - -// java_fuzz builds and links sources into a `.jar` file for the device. -// This generates .class files in a jar which can then be instrumented before -// fuzzing in Android Runtime (ART: Android OS on emulator or device) -func JavaFuzzFactory() android.Module { - module := &JavaFuzzLibrary{} - module.addHostAndDeviceProperties() - module.AddProperties(&module.jniProperties) - module.Module.properties.Installable = proptools.BoolPtr(true) - module.AddProperties(&module.fuzzPackagedModule.FuzzProperties) - module.Module.dexpreopter.isTest = true - module.Module.linter.properties.Lint.Test = proptools.BoolPtr(true) - InitJavaModuleMultiTargets(module, android.DeviceSupported) - return module -} - -// Responsible for generating rules that package host fuzz targets into -// a zip file. -type javaFuzzHostPackager struct { +type javaFuzzPackager struct { fuzz.FuzzPackager } -// Responsible for generating rules that package device fuzz targets into -// a zip file. -type javaFuzzDevicePackager struct { - fuzz.FuzzPackager +func javaFuzzPackagingFactory() android.Singleton { + return &javaFuzzPackager{} } -func javaFuzzHostPackagingFactory() android.Singleton { - return &javaFuzzHostPackager{} -} - -func javaFuzzDevicePackagingFactory() android.Singleton { - return &javaFuzzDevicePackager{} -} - -func (s *javaFuzzHostPackager) GenerateBuildActions(ctx android.SingletonContext) { - generateBuildActions(&s.FuzzPackager, hostString, ctx) -} - -func (s *javaFuzzDevicePackager) GenerateBuildActions(ctx android.SingletonContext) { - generateBuildActions(&s.FuzzPackager, targetString, ctx) -} - -func generateBuildActions(s *fuzz.FuzzPackager, hostOrTargetString string, ctx android.SingletonContext) { +func (s *javaFuzzPackager) GenerateBuildActions(ctx android.SingletonContext) { // Map between each architecture + host/device combination. archDirs := make(map[fuzz.ArchOs][]fuzz.FileToZip) - // List of individual fuzz targets. s.FuzzTargets = make(map[string]bool) - ctx.VisitAllModules(func(module android.Module) { // Discard non-fuzz targets. - javaFuzzModule, ok := module.(*JavaFuzzLibrary) + javaFuzzModule, ok := module.(*JavaFuzzTest) if !ok { return } - if hostOrTargetString == hostString { - if !javaFuzzModule.Host() { - return - } - } else if hostOrTargetString == targetString { - if javaFuzzModule.Host() || javaFuzzModule.Target().HostCross { - return - } + hostOrTargetString := "target" + if javaFuzzModule.Host() { + hostOrTargetString = "host" } fuzzModuleValidator := fuzz.FuzzModule{ @@ -246,7 +171,7 @@ func generateBuildActions(s *fuzz.FuzzPackager, hostOrTargetString string, ctx a var files []fuzz.FileToZip builder := android.NewRuleBuilder(pctx, ctx) - // Package the artifacts (data, corpus, config and dictionary into a zipfile. + // Package the artifacts (data, corpus, config and dictionary) into a zipfile. files = s.PackageArtifacts(ctx, module, javaFuzzModule.fuzzPackagedModule, archDir, builder) // Add .jar @@ -261,27 +186,14 @@ func generateBuildActions(s *fuzz.FuzzPackager, hostOrTargetString string, ctx a if !ok { return } - }) s.CreateFuzzPackage(ctx, archDirs, fuzz.Java, pctx) } -func (s *javaFuzzHostPackager) MakeVars(ctx android.MakeVarsContext) { +func (s *javaFuzzPackager) MakeVars(ctx android.MakeVarsContext) { packages := s.Packages.Strings() sort.Strings(packages) - - ctx.Strict("SOONG_JAVA_FUZZ_HOST_PACKAGING_ARCH_MODULES", strings.Join(packages, " ")) - + ctx.Strict("SOONG_JAVA_FUZZ_PACKAGING_ARCH_MODULES", strings.Join(packages, " ")) // Preallocate the slice of fuzz targets to minimize memory allocations. - s.PreallocateSlice(ctx, "ALL_JAVA_FUZZ_HOST_TARGETS") -} - -func (s *javaFuzzDevicePackager) MakeVars(ctx android.MakeVarsContext) { - packages := s.Packages.Strings() - sort.Strings(packages) - - ctx.Strict("SOONG_JAVA_FUZZ_DEVICE_PACKAGING_ARCH_MODULES", strings.Join(packages, " ")) - - // Preallocate the slice of fuzz targets to minimize memory allocations. - s.PreallocateSlice(ctx, "ALL_JAVA_FUZZ_DEVICE_TARGETS") + s.PreallocateSlice(ctx, "ALL_JAVA_FUZZ_TARGETS") } diff --git a/java/fuzz_test.go b/java/fuzz_test.go index 186c3aa95..dd1e96b3e 100644 --- a/java/fuzz_test.go +++ b/java/fuzz_test.go @@ -31,17 +31,15 @@ var prepForJavaFuzzTest = android.GroupFixturePreparers( func TestJavaFuzz(t *testing.T) { result := prepForJavaFuzzTest.RunTestWithBp(t, ` - java_fuzz_host { + java_fuzz { name: "foo", srcs: ["a.java"], + host_supported: true, + device_supported: false, libs: ["bar"], static_libs: ["baz"], jni_libs: [ "libjni", - ], - sanitizers: [ - "address", - "fuzzer", ], } @@ -84,7 +82,7 @@ func TestJavaFuzz(t *testing.T) { } ctx := result.TestContext - foo := ctx.ModuleForTests("foo", osCommonTarget).Module().(*JavaFuzzLibrary) + foo := ctx.ModuleForTests("foo", osCommonTarget).Module().(*JavaFuzzTest) expected := "lib64/libjni.so" if runtime.GOOS == "darwin" { diff --git a/java/java.go b/java/java.go index 874f93576..4fffec882 100644 --- a/java/java.go +++ b/java/java.go @@ -1138,7 +1138,6 @@ func (j *TestHost) DepsMutator(ctx android.BottomUpMutatorContext) { } j.addDataDeviceBinsDeps(ctx) - j.deps(ctx) }