Create soong-generated filesystem diff test
Running `m soong_generated_filesystem_tests` will diff the
soong-generated system image with the make-generated one.
Currently, this test fails, but we can start working on narrowing it
down now.
Bug: 371351099
Test: m soong_generated_filesystem_tests
Change-Id: I6e341607415b3676e758417a587f69c247652c3a
diff --git a/fsgen/filesystem_creator.go b/fsgen/filesystem_creator.go
index ca948f4..eb4f318 100644
--- a/fsgen/filesystem_creator.go
+++ b/fsgen/filesystem_creator.go
@@ -17,12 +17,16 @@
import (
"android/soong/android"
"android/soong/filesystem"
+ "crypto/sha256"
"fmt"
"strconv"
+ "github.com/google/blueprint"
"github.com/google/blueprint/proptools"
)
+var pctx = android.NewPackageContext("android/soong/fsgen")
+
func init() {
registerBuildComponents(android.InitRegistrationContext)
}
@@ -31,14 +35,22 @@
ctx.RegisterModuleType("soong_filesystem_creator", filesystemCreatorFactory)
}
+type filesystemCreatorProps struct {
+ Generated_partition_types []string `blueprint:"mutated"`
+ Unsupported_partition_types []string `blueprint:"mutated"`
+}
+
type filesystemCreator struct {
android.ModuleBase
+
+ properties filesystemCreatorProps
}
func filesystemCreatorFactory() android.Module {
module := &filesystemCreator{}
android.InitAndroidModule(module)
+ module.AddProperties(&module.properties)
android.AddLoadHook(module, func(ctx android.LoadHookContext) {
module.createInternalModules(ctx)
})
@@ -47,36 +59,62 @@
}
func (f *filesystemCreator) createInternalModules(ctx android.LoadHookContext) {
- f.createSystemImage(ctx)
+ for _, partitionType := range []string{"system"} {
+ if f.createPartition(ctx, partitionType) {
+ f.properties.Generated_partition_types = append(f.properties.Generated_partition_types, partitionType)
+ } else {
+ f.properties.Unsupported_partition_types = append(f.properties.Unsupported_partition_types, partitionType)
+ }
+ }
}
-func (f *filesystemCreator) createSystemImage(ctx android.LoadHookContext) {
+func (f *filesystemCreator) generatedModuleNameForPartition(cfg android.Config, partitionType string) string {
+ prefix := "soong"
+ if cfg.HasDeviceProduct() {
+ prefix = cfg.DeviceProduct()
+ }
+ return fmt.Sprintf("%s_generated_%s_image", prefix, partitionType)
+}
+
+// Creates a soong module to build the given partition. Returns false if we can't support building
+// it.
+func (f *filesystemCreator) createPartition(ctx android.LoadHookContext, partitionType string) bool {
baseProps := &struct {
Name *string
}{
- Name: proptools.StringPtr(fmt.Sprintf("%s_generated_system_image", ctx.Config().DeviceProduct())),
+ Name: proptools.StringPtr(f.generatedModuleNameForPartition(ctx.Config(), partitionType)),
}
- fsProps := &(filesystem.FilesystemProperties{})
+ fsProps := &filesystem.FilesystemProperties{}
+
+ // Don't build this module on checkbuilds, the soong-built partitions are still in-progress
+ // and sometimes don't build.
+ fsProps.Unchecked_module = proptools.BoolPtr(true)
+
partitionVars := ctx.Config().ProductVariables().PartitionVarsForSoongMigrationOnlyDoNotUse
- systemPartitionVars := partitionVars.PartitionQualifiedVariables["system"]
+ specificPartitionVars := partitionVars.PartitionQualifiedVariables[partitionType]
// BOARD_AVB_ENABLE
fsProps.Use_avb = proptools.BoolPtr(partitionVars.BoardAvbEnable)
// BOARD_AVB_KEY_PATH
- fsProps.Avb_private_key = proptools.StringPtr(systemPartitionVars.BoardAvbKeyPath)
+ fsProps.Avb_private_key = proptools.StringPtr(specificPartitionVars.BoardAvbKeyPath)
// BOARD_AVB_ALGORITHM
- fsProps.Avb_algorithm = proptools.StringPtr(systemPartitionVars.BoardAvbAlgorithm)
+ fsProps.Avb_algorithm = proptools.StringPtr(specificPartitionVars.BoardAvbAlgorithm)
// BOARD_AVB_SYSTEM_ROLLBACK_INDEX
- if rollbackIndex, err := strconv.ParseInt(systemPartitionVars.BoardAvbRollbackIndex, 10, 64); err == nil {
+ if rollbackIndex, err := strconv.ParseInt(specificPartitionVars.BoardAvbRollbackIndex, 10, 64); err == nil {
fsProps.Rollback_index = proptools.Int64Ptr(rollbackIndex)
}
- fsProps.Partition_name = proptools.StringPtr("system")
+ fsProps.Partition_name = proptools.StringPtr(partitionType)
// BOARD_SYSTEMIMAGE_FILE_SYSTEM_TYPE
- fsProps.Type = proptools.StringPtr(systemPartitionVars.BoardFileSystemType)
+ fsProps.Type = proptools.StringPtr(specificPartitionVars.BoardFileSystemType)
+ if *fsProps.Type != "ext4" {
+ // Currently the android_filesystem module type only supports ext4:
+ // https://cs.android.com/android/platform/superproject/main/+/main:build/soong/filesystem/filesystem.go;l=416;drc=98047cfd07944b297a12d173453bc984806760d2
+ return false
+ }
- fsProps.Base_dir = proptools.StringPtr("system")
+ fsProps.Base_dir = proptools.StringPtr(partitionType)
fsProps.Gen_aconfig_flags_pb = proptools.BoolPtr(true)
@@ -103,9 +141,77 @@
// - filesystemProperties.Build_logtags
// - filesystemProperties.Fsverity.Libs
// - systemImageProperties.Linker_config_src
- ctx.CreateModule(filesystem.SystemImageFactory, baseProps, fsProps)
+ var module android.Module
+ if partitionType == "system" {
+ module = ctx.CreateModule(filesystem.SystemImageFactory, baseProps, fsProps)
+ } else {
+ module = ctx.CreateModule(filesystem.FilesystemFactory, baseProps, fsProps)
+ }
+ module.HideFromMake()
+ return true
+}
+
+func (f *filesystemCreator) createDiffTest(ctx android.ModuleContext, partitionType string) android.Path {
+ partitionModuleName := f.generatedModuleNameForPartition(ctx.Config(), partitionType)
+ systemImage := ctx.GetDirectDepWithTag(partitionModuleName, generatedFilesystemDepTag)
+ filesystemInfo, ok := android.OtherModuleProvider(ctx, systemImage, filesystem.FilesystemProvider)
+ if !ok {
+ ctx.ModuleErrorf("Expected module %s to provide FileysystemInfo", partitionModuleName)
+ }
+ makeFileList := android.PathForArbitraryOutput(ctx, fmt.Sprintf("target/product/%s/obj/PACKAGING/%s_intermediates/file_list.txt", ctx.Config().DeviceName(), partitionType))
+ // For now, don't allowlist anything. The test will fail, but that's fine in the current
+ // early stages where we're just figuring out what we need
+ emptyAllowlistFile := android.PathForModuleOut(ctx, "allowlist_%s.txt", partitionModuleName)
+ android.WriteFileRule(ctx, emptyAllowlistFile, "")
+ diffTestResultFile := android.PathForModuleOut(ctx, "diff_test_%s.txt", partitionModuleName)
+
+ builder := android.NewRuleBuilder(pctx, ctx)
+ builder.Command().BuiltTool("file_list_diff").
+ Input(makeFileList).
+ Input(filesystemInfo.FileListFile).
+ Input(emptyAllowlistFile).
+ Text(partitionModuleName)
+ builder.Command().Text("touch").Output(diffTestResultFile)
+ builder.Build(partitionModuleName+" diff test", partitionModuleName+" diff test")
+ return diffTestResultFile
+}
+
+func createFailingCommand(ctx android.ModuleContext, message string) android.Path {
+ hasher := sha256.New()
+ hasher.Write([]byte(message))
+ filename := fmt.Sprintf("failing_command_%x.txt", hasher.Sum(nil))
+ file := android.PathForModuleOut(ctx, filename)
+ builder := android.NewRuleBuilder(pctx, ctx)
+ builder.Command().Textf("echo %s", proptools.NinjaAndShellEscape(message))
+ builder.Command().Text("exit 1 #").Output(file)
+ builder.Build("failing command "+filename, "failing command "+filename)
+ return file
+}
+
+type systemImageDepTagType struct {
+ blueprint.BaseDependencyTag
+}
+
+var generatedFilesystemDepTag systemImageDepTagType
+
+func (f *filesystemCreator) DepsMutator(ctx android.BottomUpMutatorContext) {
+ for _, partitionType := range f.properties.Generated_partition_types {
+ ctx.AddDependency(ctx.Module(), generatedFilesystemDepTag, f.generatedModuleNameForPartition(ctx.Config(), partitionType))
+ }
}
func (f *filesystemCreator) GenerateAndroidBuildActions(ctx android.ModuleContext) {
+ if ctx.ModuleDir() != "build/soong/fsgen" {
+ ctx.ModuleErrorf("There can only be one soong_filesystem_creator in build/soong/fsgen")
+ }
+ f.HideFromMake()
+ var diffTestFiles []android.Path
+ for _, partitionType := range f.properties.Generated_partition_types {
+ diffTestFiles = append(diffTestFiles, f.createDiffTest(ctx, partitionType))
+ }
+ for _, partitionType := range f.properties.Unsupported_partition_types {
+ diffTestFiles = append(diffTestFiles, createFailingCommand(ctx, fmt.Sprintf("Couldn't build %s partition", partitionType)))
+ }
+ ctx.Phony("soong_generated_filesystem_tests", diffTestFiles...)
}