Merge changes from topic "mkboot" (7a1c2b18) · Commits · e / os / android_build_soong

android/packaging.go

+28 −0

Original line number	Diff line number	Diff line
		@@ -49,6 +49,11 @@ func (p *PackagingSpec) FileName() string {
		return ""
		}

		// Path relative to the root of the package
		func (p *PackagingSpec) RelPathInPackage() string {
		return p.relPathInPackage
		}

		type PackageModule interface {
		Module
		packagingBase() *PackagingBase
		@@ -87,9 +92,17 @@ type packagingMultilibProperties struct {
		Lib64 depsProperty `android:"arch_variant"`
		}

		type packagingArchProperties struct {
		Arm64 depsProperty
		Arm depsProperty
		X86_64 depsProperty
		X86 depsProperty
		}

		type PackagingProperties struct {
		Deps []string `android:"arch_variant"`
		Multilib packagingMultilibProperties `android:"arch_variant"`
		Arch packagingArchProperties
		}

		func InitPackageModule(p PackageModule) {
		@@ -116,6 +129,7 @@ func (p *PackagingBase) getDepsForArch(ctx BaseModuleContext, arch ArchType) []s
		} else if arch == Common {
		ret = append(ret, p.properties.Multilib.Common.Deps...)
		}

		for i, t := range ctx.MultiTargets() {
		if t.Arch.ArchType == arch {
		ret = append(ret, p.properties.Deps...)
		@@ -124,6 +138,20 @@ func (p *PackagingBase) getDepsForArch(ctx BaseModuleContext, arch ArchType) []s
		}
		}
		}

		if ctx.Arch().ArchType == Common {
		switch arch {
		case Arm64:
		ret = append(ret, p.properties.Arch.Arm64.Deps...)
		case Arm:
		ret = append(ret, p.properties.Arch.Arm.Deps...)
		case X86_64:
		ret = append(ret, p.properties.Arch.X86_64.Deps...)
		case X86:
		ret = append(ret, p.properties.Arch.X86.Deps...)
		}
		}

		return FirstUniqueStrings(ret)
		}

android/packaging_test.go

+158 −10

Original line number	Diff line number	Diff line
		@@ -61,13 +61,20 @@ type packageTestModule struct {
		entries []string
		}

		func packageTestModuleFactory() Module {
		func packageMultiTargetTestModuleFactory() Module {
		module := &packageTestModule{}
		InitPackageModule(module)
		InitAndroidMultiTargetsArchModule(module, DeviceSupported, MultilibCommon)
		return module
		}

		func packageTestModuleFactory() Module {
		module := &packageTestModule{}
		InitPackageModule(module)
		InitAndroidArchModule(module, DeviceSupported, MultilibBoth)
		return module
		}

		func (m *packageTestModule) DepsMutator(ctx BottomUpMutatorContext) {
		m.AddDeps(ctx, installDepTag{})
		}
		@@ -77,14 +84,22 @@ func (m *packageTestModule) GenerateAndroidBuildActions(ctx ModuleContext) {
		m.entries = m.CopyDepsToZip(ctx, zipFile)
		}

		func runPackagingTest(t *testing.T, bp string, expected []string) {
		func runPackagingTest(t *testing.T, multitarget bool, bp string, expected []string) {
		t.Helper()

		config := TestArchConfig(buildDir, nil, bp, nil)

		ctx := NewTestArchContext(config)
		ctx.RegisterModuleType("component", componentTestModuleFactory)

		var archVariant string
		if multitarget {
		archVariant = "android_common"
		ctx.RegisterModuleType("package_module", packageMultiTargetTestModuleFactory)
		} else {
		archVariant = "android_arm64_armv8-a"
		ctx.RegisterModuleType("package_module", packageTestModuleFactory)
		}
		ctx.Register()

		_, errs := ctx.ParseFileList(".", []string{"Android.bp"})
		@@ -92,7 +107,7 @@ func runPackagingTest(t *testing.T, bp string, expected []string) {
		_, errs = ctx.PrepareBuildActions(config)
		FailIfErrored(t, errs)

		p := ctx.ModuleForTests("package", "android_common").Module().(*packageTestModule)
		p := ctx.ModuleForTests("package", archVariant).Module().(*packageTestModule)
		actual := p.entries
		actual = SortedUniqueStrings(actual)
		expected = SortedUniqueStrings(expected)
		@@ -101,8 +116,9 @@ func runPackagingTest(t *testing.T, bp string, expected []string) {
		}
		}

		func TestPackagingBase(t *testing.T) {
		runPackagingTest(t,
		func TestPackagingBaseMultiTarget(t *testing.T) {
		multiTarget := true
		runPackagingTest(t, multiTarget,
		`
		component {
		name: "foo",
		@@ -114,7 +130,7 @@ func TestPackagingBase(t *testing.T) {
		}
		`, []string{"lib64/foo"})

		runPackagingTest(t,
		runPackagingTest(t, multiTarget,
		`
		component {
		name: "foo",
		@@ -131,7 +147,7 @@ func TestPackagingBase(t *testing.T) {
		}
		`, []string{"lib64/foo", "lib64/bar"})

		runPackagingTest(t,
		runPackagingTest(t, multiTarget,
		`
		component {
		name: "foo",
		@@ -149,7 +165,7 @@ func TestPackagingBase(t *testing.T) {
		}
		`, []string{"lib32/foo", "lib32/bar", "lib64/foo", "lib64/bar"})

		runPackagingTest(t,
		runPackagingTest(t, multiTarget,
		`
		component {
		name: "foo",
		@@ -172,7 +188,7 @@ func TestPackagingBase(t *testing.T) {
		}
		`, []string{"lib32/foo", "lib32/bar", "lib64/foo"})

		runPackagingTest(t,
		runPackagingTest(t, multiTarget,
		`
		component {
		name: "foo",
		@@ -193,4 +209,136 @@ func TestPackagingBase(t *testing.T) {
		compile_multilib: "both",
		}
		`, []string{"lib32/foo", "lib64/foo", "lib64/bar"})

		runPackagingTest(t, multiTarget,
		`
		component {
		name: "foo",
		}

		component {
		name: "bar",
		}

		component {
		name: "baz",
		}

		package_module {
		name: "package",
		deps: ["foo"],
		arch: {
		arm64: {
		deps: ["bar"],
		},
		x86_64: {
		deps: ["baz"],
		},
		},
		compile_multilib: "both",
		}
		`, []string{"lib32/foo", "lib64/foo", "lib64/bar"})
		}

		func TestPackagingBaseSingleTarget(t *testing.T) {
		multiTarget := false
		runPackagingTest(t, multiTarget,
		`
		component {
		name: "foo",
		}

		package_module {
		name: "package",
		deps: ["foo"],
		}
		`, []string{"lib64/foo"})

		runPackagingTest(t, multiTarget,
		`
		component {
		name: "foo",
		deps: ["bar"],
		}

		component {
		name: "bar",
		}

		package_module {
		name: "package",
		deps: ["foo"],
		}
		`, []string{"lib64/foo", "lib64/bar"})

		runPackagingTest(t, multiTarget,
		`
		component {
		name: "foo",
		}

		component {
		name: "bar",
		compile_multilib: "32",
		}

		package_module {
		name: "package",
		deps: ["foo"],
		multilib: {
		lib32: {
		deps: ["bar"],
		},
		},
		}
		`, []string{"lib64/foo"})

		runPackagingTest(t, multiTarget,
		`
		component {
		name: "foo",
		}

		component {
		name: "bar",
		}

		package_module {
		name: "package",
		deps: ["foo"],
		multilib: {
		lib64: {
		deps: ["bar"],
		},
		},
		}
		`, []string{"lib64/foo", "lib64/bar"})

		runPackagingTest(t, multiTarget,
		`
		component {
		name: "foo",
		}

		component {
		name: "bar",
		}

		component {
		name: "baz",
		}

		package_module {
		name: "package",
		deps: ["foo"],
		arch: {
		arm64: {
		deps: ["bar"],
		},
		x86_64: {
		deps: ["baz"],
		},
		},
		}
		`, []string{"lib64/foo", "lib64/bar"})
		}

filesystem/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -7,6 +7,7 @@ bootstrap_go_package {
		"soong-android",
		],
		srcs: [
		"bootimg.go",
		"filesystem.go",
		],
		testSrcs: [

filesystem/bootimg.go

0 → 100644

+222 −0

Original line number	Diff line number	Diff line
		// Copyright (C) 2021 The Android Open Source Project
		//
		// Licensed under the Apache License, Version 2.0 (the "License");
		// you may not use this file except in compliance with the License.
		// You may obtain a copy of the License at
		//
		// http://www.apache.org/licenses/LICENSE-2.0
		//
		// Unless required by applicable law or agreed to in writing, software
		// distributed under the License is distributed on an "AS IS" BASIS,
		// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		// See the License for the specific language governing permissions and
		// limitations under the License.

		package filesystem

		import (
		"fmt"
		"strconv"

		"github.com/google/blueprint"
		"github.com/google/blueprint/proptools"

		"android/soong/android"
		)

		func init() {
		android.RegisterModuleType("bootimg", bootimgFactory)
		}

		type bootimg struct {
		android.ModuleBase

		properties bootimgProperties

		output android.OutputPath
		installDir android.InstallPath
		}

		type bootimgProperties struct {
		// Path to the linux kernel prebuilt file
		Kernel_prebuilt *string `android:"arch_variant,path"`

		// Filesystem module that is used as ramdisk
		Ramdisk_module *string

		// Path to the device tree blob (DTB) prebuilt file to add to this boot image
		Dtb_prebuilt *string `android:"arch_variant,path"`

		// Header version number. Must be set to one of the version numbers that are currently
		// supported. Refer to
		// https://source.android.com/devices/bootloader/boot-image-header
		Header_version *string

		// Determines if this image is for the vendor_boot partition. Default is false. Refer to
		// https://source.android.com/devices/bootloader/partitions/vendor-boot-partitions
		Vendor_boot *bool

		// Optional kernel commandline
		Cmdline *string

		// When set to true, sign the image with avbtool. Default is false.
		Use_avb *bool

		// Name of the partition stored in vbmeta desc. Defaults to the name of this module.
		Partition_name *string

		// Path to the private key that avbtool will use to sign this filesystem image.
		// TODO(jiyong): allow apex_key to be specified here
		Avb_private_key *string `android:"path"`

		// Hash and signing algorithm for avbtool. Default is SHA256_RSA4096.
		Avb_algorithm *string
		}

		// bootimg is the image for the boot partition. It consists of header, kernel, ramdisk, and dtb.
		func bootimgFactory() android.Module {
		module := &bootimg{}
		module.AddProperties(&module.properties)
		android.InitAndroidArchModule(module, android.DeviceSupported, android.MultilibFirst)
		return module
		}

		type bootimgDep struct {
		blueprint.BaseDependencyTag
		kind string
		}

		var bootimgRamdiskDep = bootimgDep{kind: "ramdisk"}

		func (b *bootimg) DepsMutator(ctx android.BottomUpMutatorContext) {
		ramdisk := proptools.String(b.properties.Ramdisk_module)
		if ramdisk != "" {
		ctx.AddDependency(ctx.Module(), bootimgRamdiskDep, ramdisk)
		}
		}

		func (b *bootimg) installFileName() string {
		return b.BaseModuleName() + ".img"
		}

		func (b *bootimg) partitionName() string {
		return proptools.StringDefault(b.properties.Partition_name, b.BaseModuleName())
		}

		func (b *bootimg) GenerateAndroidBuildActions(ctx android.ModuleContext) {
		var unsignedOutput android.OutputPath
		if proptools.Bool(b.properties.Vendor_boot) {
		unsignedOutput = b.buildVendorBootImage(ctx)
		} else {
		// TODO(jiyong): fix this
		ctx.PropertyErrorf("vendor_boot", "only vendor_boot:true is supported")
		}

		if proptools.Bool(b.properties.Use_avb) {
		b.output = b.signImage(ctx, unsignedOutput)
		} else {
		b.output = unsignedOutput
		}

		b.installDir = android.PathForModuleInstall(ctx, "etc")
		ctx.InstallFile(b.installDir, b.installFileName(), b.output)
		}

		func (b *bootimg) buildVendorBootImage(ctx android.ModuleContext) android.OutputPath {
		output := android.PathForModuleOut(ctx, "unsigned.img").OutputPath
		builder := android.NewRuleBuilder(pctx, ctx)
		cmd := builder.Command().BuiltTool("mkbootimg")

		kernel := android.OptionalPathForModuleSrc(ctx, b.properties.Kernel_prebuilt)
		if kernel.Valid() {
		ctx.PropertyErrorf("kernel_prebuilt", "vendor_boot partition can't have kernel")
		return output
		}

		dtbName := proptools.String(b.properties.Dtb_prebuilt)
		if dtbName == "" {
		ctx.PropertyErrorf("dtb_prebuilt", "must be set")
		return output
		}
		dtb := android.PathForModuleSrc(ctx, dtbName)
		cmd.FlagWithInput("--dtb ", dtb)

		cmdline := proptools.String(b.properties.Cmdline)
		if cmdline != "" {
		cmd.FlagWithArg("--vendor_cmdline ", "\""+cmdline+"\"")
		}

		headerVersion := proptools.String(b.properties.Header_version)
		if headerVersion == "" {
		ctx.PropertyErrorf("header_version", "must be set")
		return output
		}
		verNum, err := strconv.Atoi(headerVersion)
		if err != nil {
		ctx.PropertyErrorf("header_version", "%q is not a number", headerVersion)
		return output
		}
		if verNum < 3 {
		ctx.PropertyErrorf("header_version", "must be 3 or higher for vendor_boot")
		return output
		}
		cmd.FlagWithArg("--header_version ", headerVersion)

		ramdiskName := proptools.String(b.properties.Ramdisk_module)
		if ramdiskName == "" {
		ctx.PropertyErrorf("ramdisk_module", "must be set")
		return output
		}
		ramdisk := ctx.GetDirectDepWithTag(ramdiskName, bootimgRamdiskDep)
		if filesystem, ok := ramdisk.(*filesystem); ok {
		cmd.FlagWithInput("--vendor_ramdisk ", filesystem.OutputPath())
		} else {
		ctx.PropertyErrorf("ramdisk", "%q is not android_filesystem module", ramdisk.Name())
		return output
		}

		cmd.FlagWithOutput("--vendor_boot ", output)

		builder.Build("build_vendor_bootimg", fmt.Sprintf("Creating %s", b.BaseModuleName()))
		return output
		}

		func (b *bootimg) signImage(ctx android.ModuleContext, unsignedImage android.OutputPath) android.OutputPath {
		signedImage := android.PathForModuleOut(ctx, "signed.img").OutputPath
		key := android.PathForModuleSrc(ctx, proptools.String(b.properties.Avb_private_key))

		builder := android.NewRuleBuilder(pctx, ctx)
		builder.Command().Text("cp").Input(unsignedImage).Output(signedImage)
		builder.Command().
		BuiltTool("avbtool").
		Flag("add_hash_footer").
		FlagWithArg("--partition_name ", b.partitionName()).
		FlagWithInput("--key ", key).
		FlagWithOutput("--image ", signedImage)

		builder.Build("sign_bootimg", fmt.Sprintf("Signing %s", b.BaseModuleName()))

		return signedImage
		}

		var _ android.AndroidMkEntriesProvider = (*bootimg)(nil)

		// Implements android.AndroidMkEntriesProvider
		func (b *bootimg) AndroidMkEntries() []android.AndroidMkEntries {
		return []android.AndroidMkEntries{android.AndroidMkEntries{
		Class: "ETC",
		OutputFile: android.OptionalPathForPath(b.output),
		ExtraEntries: []android.AndroidMkExtraEntriesFunc{
		func(entries *android.AndroidMkEntries) {
		entries.SetString("LOCAL_MODULE_PATH", b.installDir.ToMakePath().String())
		entries.SetString("LOCAL_INSTALLED_MODULE_STEM", b.installFileName())
		},
		},
		}}
		}

		var _ Filesystem = (*bootimg)(nil)

		func (b *bootimg) OutputPath() android.Path {
		return b.output
		}

filesystem/filesystem.go

+86 −6

Original line number	Diff line number	Diff line
		@@ -47,6 +47,10 @@ type filesystemProperties struct {

		// Hash and signing algorithm for avbtool. Default is SHA256_RSA4096.
		Avb_algorithm *string

		// Type of the filesystem. Currently, ext4 and compressed_cpio are supported. Default is
		// ext4.
		Type *string
		}

		// android_filesystem packages a set of modules and their transitive dependencies into a filesystem
		@@ -71,6 +75,27 @@ func (f *filesystem) DepsMutator(ctx android.BottomUpMutatorContext) {
		f.AddDeps(ctx, dependencyTag)
		}

		type fsType int

		const (
		ext4Type fsType = iota
		compressedCpioType
		unknown
		)

		func (f *filesystem) fsType(ctx android.ModuleContext) fsType {
		typeStr := proptools.StringDefault(f.properties.Type, "ext4")
		switch typeStr {
		case "ext4":
		return ext4Type
		case "compressed_cpio":
		return compressedCpioType
		default:
		ctx.PropertyErrorf("type", "%q not supported", typeStr)
		return unknown
		}
		}

		func (f *filesystem) installFileName() string {
		return f.BaseModuleName() + ".img"
		}
		@@ -78,6 +103,20 @@ func (f *filesystem) installFileName() string {
		var pctx = android.NewPackageContext("android/soong/filesystem")

		func (f *filesystem) GenerateAndroidBuildActions(ctx android.ModuleContext) {
		switch f.fsType(ctx) {
		case ext4Type:
		f.output = f.buildImageUsingBuildImage(ctx)
		case compressedCpioType:
		f.output = f.buildCompressedCpioImage(ctx)
		default:
		return
		}

		f.installDir = android.PathForModuleInstall(ctx, "etc")
		ctx.InstallFile(f.installDir, f.installFileName(), f.output)
		}

		func (f *filesystem) buildImageUsingBuildImage(ctx android.ModuleContext) android.OutputPath {
		zipFile := android.PathForModuleOut(ctx, "temp.zip").OutputPath
		f.CopyDepsToZip(ctx, zipFile)

		@@ -89,19 +128,18 @@ func (f *filesystem) GenerateAndroidBuildActions(ctx android.ModuleContext) {
		Input(zipFile)

		propFile, toolDeps := f.buildPropFile(ctx)
		f.output = android.PathForModuleOut(ctx, f.installFileName()).OutputPath
		output := android.PathForModuleOut(ctx, f.installFileName()).OutputPath
		builder.Command().BuiltTool("build_image").
		Text(rootDir.String()). // input directory
		Input(propFile).
		Implicits(toolDeps).
		Output(f.output).
		Output(output).
		Text(rootDir.String()) // directory where to find fs_config_files\|dirs

		// rootDir is not deleted. Might be useful for quick inspection.
		builder.Build("build_filesystem_image", fmt.Sprintf("Creating filesystem %s", f.BaseModuleName()))

		f.installDir = android.PathForModuleInstall(ctx, "etc")
		ctx.InstallFile(f.installDir, f.installFileName(), f.output)
		return output
		}

		func (f *filesystem) buildPropFile(ctx android.ModuleContext) (propFile android.OutputPath, toolDeps android.Paths) {
		@@ -120,8 +158,17 @@ func (f *filesystem) buildPropFile(ctx android.ModuleContext) (propFile android.
		deps = append(deps, path)
		}

		// TODO(jiyong): support more filesystem types other than ext4
		addStr("fs_type", "ext4")
		// Type string that build_image.py accepts.
		fsTypeStr := func(t fsType) string {
		switch t {
		// TODO(jiyong): add more types like f2fs, erofs, etc.
		case ext4Type:
		return "ext4"
		}
		panic(fmt.Errorf("unsupported fs type %v", t))
		}

		addStr("fs_type", fsTypeStr(f.fsType(ctx)))
		addStr("mount_point", "system")
		addStr("use_dynamic_partition_size", "true")
		addPath("ext_mkuserimg", ctx.Config().HostToolPath(ctx, "mkuserimg_mke2fs"))
		@@ -154,6 +201,39 @@ func (f *filesystem) buildPropFile(ctx android.ModuleContext) (propFile android.
		return propFile, deps
		}

		func (f *filesystem) buildCompressedCpioImage(ctx android.ModuleContext) android.OutputPath {
		if proptools.Bool(f.properties.Use_avb) {
		ctx.PropertyErrorf("use_avb", "signing compresed cpio image using avbtool is not supported."+
		"Consider adding this to bootimg module and signing the entire boot image.")
		}

		zipFile := android.PathForModuleOut(ctx, "temp.zip").OutputPath
		f.CopyDepsToZip(ctx, zipFile)

		rootDir := android.PathForModuleOut(ctx, "root").OutputPath
		builder := android.NewRuleBuilder(pctx, ctx)
		builder.Command().
		BuiltTool("zipsync").
		FlagWithArg("-d ", rootDir.String()). // zipsync wipes this. No need to clear.
		Input(zipFile)

		output := android.PathForModuleOut(ctx, f.installFileName()).OutputPath
		builder.Command().
		BuiltTool("mkbootfs").
		Text(rootDir.String()). // input directory
		Text("\|").
		BuiltTool("lz4").
		Flag("--favor-decSpeed"). // for faster boot
		Flag("-12"). // maximum compression level
		Flag("-l"). // legacy format for kernel
		Text(">").Output(output)

		// rootDir is not deleted. Might be useful for quick inspection.
		builder.Build("build_compressed_cpio_image", fmt.Sprintf("Creating filesystem %s", f.BaseModuleName()))

		return output
		}

		var _ android.AndroidMkEntriesProvider = (*filesystem)(nil)

		// Implements android.AndroidMkEntriesProvider