From 0fbbc2b0d4bcebe2be1f91301f972be97b6fdbdc Mon Sep 17 00:00:00 2001 From: Jooyung Han Date: Fri, 25 Mar 2022 12:35:46 +0900 Subject: [PATCH] android_system_image only packages "system" items android_system_image filers packaging items installed outside "system" partition. Some packaging items install related items to different partitions but putting them altogether to android_system_image doesn't make sense. (android_system_image is suppposed to be "system" partition) To be specific, this filters out "apex" partition items. "apex" partition is used by APEX installation to install APEX contents to paths similar to activated paths on device so that symbol lookup works well with APEX contents. Bug: 225121718 Test: atest MicrodroidHostTestCases Test: debugfs /microdroid.img -R 'ls system' shows no "com.android.runtime" Change-Id: Ibc3d85ead2fda99e231132ce8ab9ccf1cc9317b7 --- filesystem/filesystem.go | 21 +++++++++++-- filesystem/filesystem_test.go | 55 +++++++++++++++++++++++++++++++++-- filesystem/system_image.go | 14 ++++++++- 3 files changed, 85 insertions(+), 5 deletions(-) diff --git a/filesystem/filesystem.go b/filesystem/filesystem.go index 9cf7bbdd0..ccf9e9d3b 100644 --- a/filesystem/filesystem.go +++ b/filesystem/filesystem.go @@ -43,8 +43,14 @@ type filesystem struct { // Function that builds extra files under the root directory and returns the files buildExtraFiles func(ctx android.ModuleContext, root android.OutputPath) android.OutputPaths + // Function that filters PackagingSpecs returned by PackagingBase.GatherPackagingSpecs() + filterPackagingSpecs func(specs map[string]android.PackagingSpec) + output android.OutputPath installDir android.InstallPath + + // For testing. Keeps the result of CopyDepsToZip() + entries []string } type symlinkDefinition struct { @@ -226,7 +232,7 @@ func (f *filesystem) buildRootZip(ctx android.ModuleContext) android.OutputPath func (f *filesystem) buildImageUsingBuildImage(ctx android.ModuleContext) android.OutputPath { depsZipFile := android.PathForModuleOut(ctx, "deps.zip").OutputPath - f.CopyDepsToZip(ctx, f.GatherPackagingSpecs(ctx), depsZipFile) + f.entries = f.CopyDepsToZip(ctx, f.gatherFilteredPackagingSpecs(ctx), depsZipFile) builder := android.NewRuleBuilder(pctx, ctx) depsBase := proptools.StringDefault(f.properties.Base_dir, ".") @@ -345,7 +351,7 @@ func (f *filesystem) buildCpioImage(ctx android.ModuleContext, compressed bool) } depsZipFile := android.PathForModuleOut(ctx, "deps.zip").OutputPath - f.CopyDepsToZip(ctx, f.GatherPackagingSpecs(ctx), depsZipFile) + f.entries = f.CopyDepsToZip(ctx, f.gatherFilteredPackagingSpecs(ctx), depsZipFile) builder := android.NewRuleBuilder(pctx, ctx) depsBase := proptools.StringDefault(f.properties.Base_dir, ".") @@ -434,3 +440,14 @@ func (f *filesystem) SignedOutputPath() android.Path { } return nil } + +// Filter the result of GatherPackagingSpecs to discard items targeting outside "system" partition. +// Note that "apex" module installs its contents to "apex"(fake partition) as well +// for symbol lookup by imitating "activated" paths. +func (f *filesystem) gatherFilteredPackagingSpecs(ctx android.ModuleContext) map[string]android.PackagingSpec { + specs := f.PackagingBase.GatherPackagingSpecs(ctx) + if f.filterPackagingSpecs != nil { + f.filterPackagingSpecs(specs) + } + return specs +} diff --git a/filesystem/filesystem_test.go b/filesystem/filesystem_test.go index e78fdffde..cda06d907 100644 --- a/filesystem/filesystem_test.go +++ b/filesystem/filesystem_test.go @@ -45,11 +45,11 @@ func TestFileSystemDeps(t *testing.T) { func TestFileSystemFillsLinkerConfigWithStubLibs(t *testing.T) { result := fixture.RunTestWithBp(t, ` - android_system_image { + android_system_image { name: "myfilesystem", deps: [ "libfoo", - "libbar", + "libbar", ], linker_config_src: "linker.config.json", } @@ -74,3 +74,54 @@ func TestFileSystemFillsLinkerConfigWithStubLibs(t *testing.T) { android.AssertStringDoesNotContain(t, "linker.config.pb should not have libbar", output.RuleParams.Command, "libbar.so") } + +func registerComponent(ctx android.RegistrationContext) { + ctx.RegisterModuleType("component", componentFactory) +} + +func componentFactory() android.Module { + m := &component{} + m.AddProperties(&m.properties) + android.InitAndroidArchModule(m, android.DeviceSupported, android.MultilibCommon) + return m +} + +type component struct { + android.ModuleBase + properties struct { + Install_copy_in_data []string + } +} + +func (c *component) GenerateAndroidBuildActions(ctx android.ModuleContext) { + output := android.PathForModuleOut(ctx, c.Name()) + dir := android.PathForModuleInstall(ctx, "components") + ctx.InstallFile(dir, c.Name(), output) + + dataDir := android.PathForModuleInPartitionInstall(ctx, "data", "components") + for _, d := range c.properties.Install_copy_in_data { + ctx.InstallFile(dataDir, d, output) + } +} + +func TestFileSystemGathersItemsOnlyInSystemPartition(t *testing.T) { + f := android.GroupFixturePreparers(fixture, android.FixtureRegisterWithContext(registerComponent)) + result := f.RunTestWithBp(t, ` + android_system_image { + name: "myfilesystem", + multilib: { + common: { + deps: ["foo"], + }, + }, + linker_config_src: "linker.config.json", + } + component { + name: "foo", + install_copy_in_data: ["bar"], + } + `) + + module := result.ModuleForTests("myfilesystem", "android_common").Module().(*systemImage) + android.AssertDeepEquals(t, "entries should have foo only", []string{"components/foo"}, module.entries) +} diff --git a/filesystem/system_image.go b/filesystem/system_image.go index 1d24d6d41..75abf702e 100644 --- a/filesystem/system_image.go +++ b/filesystem/system_image.go @@ -37,6 +37,7 @@ func systemImageFactory() android.Module { module := &systemImage{} module.AddProperties(&module.properties) module.filesystem.buildExtraFiles = module.buildExtraFiles + module.filesystem.filterPackagingSpecs = module.filterPackagingSpecs initFilesystemModule(&module.filesystem) return module } @@ -53,7 +54,7 @@ func (s *systemImage) buildLinkerConfigFile(ctx android.ModuleContext, root andr // we need "Module"s for packaging items var otherModules []android.Module - deps := s.GatherPackagingSpecs(ctx) + deps := s.gatherFilteredPackagingSpecs(ctx) ctx.WalkDeps(func(child, parent android.Module) bool { for _, ps := range child.PackagingSpecs() { if _, ok := deps[ps.RelPathInPackage()]; ok { @@ -68,3 +69,14 @@ func (s *systemImage) buildLinkerConfigFile(ctx android.ModuleContext, root andr builder.Build("conv_linker_config", "Generate linker config protobuf "+output.String()) return output } + +// Filter the result of GatherPackagingSpecs to discard items targeting outside "system" partition. +// Note that "apex" module installs its contents to "apex"(fake partition) as well +// for symbol lookup by imitating "activated" paths. +func (s *systemImage) filterPackagingSpecs(specs map[string]android.PackagingSpec) { + for k, ps := range specs { + if ps.Partition() != "system" { + delete(specs, k) + } + } +}