diff --git a/apex/androidmk.go b/apex/androidmk.go index 993260c7e..fe89b73cc 100644 --- a/apex/androidmk.go +++ b/apex/androidmk.go @@ -36,6 +36,33 @@ func (a *apexBundle) AndroidMk() android.AndroidMkData { return a.androidMkForType() } +// nameInMake converts apexFileClass into the corresponding class name in Make. +func (class apexFileClass) nameInMake() string { + switch class { + case etc: + return "ETC" + case nativeSharedLib: + return "SHARED_LIBRARIES" + case nativeExecutable, shBinary, pyBinary, goBinary: + return "EXECUTABLES" + case javaSharedLib: + return "JAVA_LIBRARIES" + case nativeTest: + return "NATIVE_TESTS" + case app, appSet: + // b/142537672 Why isn't this APP? We want to have full control over + // the paths and file names of the apk file under the flattend APEX. + // If this is set to APP, then the paths and file names are modified + // by the Make build system. For example, it is installed to + // /system/apex//app//./ instead of + // /system/apex//app/ because the build system automatically + // appends module name (which is . to the path. + return "ETC" + default: + panic(fmt.Errorf("unknown class %d", class)) + } +} + func (a *apexBundle) androidMkForFiles(w io.Writer, apexBundleName, apexName, moduleDir string, apexAndroidMkData android.AndroidMkData) []string { @@ -68,10 +95,10 @@ func (a *apexBundle) androidMkForFiles(w io.Writer, apexBundleName, apexName, mo var postInstallCommands []string for _, fi := range a.filesInfo { - if a.linkToSystemLib && fi.transitiveDep && fi.AvailableToPlatform() { + if a.linkToSystemLib && fi.transitiveDep && fi.availableToPlatform() { // TODO(jiyong): pathOnDevice should come from fi.module, not being calculated here - linkTarget := filepath.Join("/system", fi.Path()) - linkPath := filepath.Join(a.installDir.ToMakePath().String(), apexBundleName, fi.Path()) + linkTarget := filepath.Join("/system", fi.path()) + linkPath := filepath.Join(a.installDir.ToMakePath().String(), apexBundleName, fi.path()) mkdirCmd := "mkdir -p " + filepath.Dir(linkPath) linkCmd := "ln -sfn " + linkTarget + " " + linkPath postInstallCommands = append(postInstallCommands, mkdirCmd, linkCmd) @@ -85,7 +112,7 @@ func (a *apexBundle) androidMkForFiles(w io.Writer, apexBundleName, apexName, mo continue } - linkToSystemLib := a.linkToSystemLib && fi.transitiveDep && fi.AvailableToPlatform() + linkToSystemLib := a.linkToSystemLib && fi.transitiveDep && fi.availableToPlatform() var moduleName string if linkToSystemLib { @@ -151,7 +178,7 @@ func (a *apexBundle) androidMkForFiles(w io.Writer, apexBundleName, apexName, mo fmt.Fprintln(w, "LOCAL_NO_NOTICE_FILE := true") } fmt.Fprintln(w, "LOCAL_PREBUILT_MODULE_FILE :=", fi.builtFile.String()) - fmt.Fprintln(w, "LOCAL_MODULE_CLASS :=", fi.class.NameInMake()) + fmt.Fprintln(w, "LOCAL_MODULE_CLASS :=", fi.class.nameInMake()) if fi.module != nil { archStr := fi.module.Target().Arch.ArchType.String() host := false @@ -189,7 +216,7 @@ func (a *apexBundle) androidMkForFiles(w io.Writer, apexBundleName, apexName, mo // soong_java_prebuilt.mk sets LOCAL_MODULE_SUFFIX := .jar Therefore // we need to remove the suffix from LOCAL_MODULE_STEM, otherwise // we will have foo.jar.jar - fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", strings.TrimSuffix(fi.Stem(), ".jar")) + fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", strings.TrimSuffix(fi.stem(), ".jar")) if javaModule, ok := fi.module.(java.ApexDependency); ok { fmt.Fprintln(w, "LOCAL_SOONG_CLASSES_JAR :=", javaModule.ImplementationAndResourcesJars()[0].String()) fmt.Fprintln(w, "LOCAL_SOONG_HEADER_JAR :=", javaModule.HeaderJars()[0].String()) @@ -205,7 +232,7 @@ func (a *apexBundle) androidMkForFiles(w io.Writer, apexBundleName, apexName, mo // soong_app_prebuilt.mk sets LOCAL_MODULE_SUFFIX := .apk Therefore // we need to remove the suffix from LOCAL_MODULE_STEM, otherwise // we will have foo.apk.apk - fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", strings.TrimSuffix(fi.Stem(), ".apk")) + fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", strings.TrimSuffix(fi.stem(), ".apk")) if app, ok := fi.module.(*java.AndroidApp); ok { if jniCoverageOutputs := app.JniCoverageOutputs(); len(jniCoverageOutputs) > 0 { fmt.Fprintln(w, "LOCAL_PREBUILT_COVERAGE_ARCHIVE :=", strings.Join(jniCoverageOutputs.Strings(), " ")) @@ -224,7 +251,7 @@ func (a *apexBundle) androidMkForFiles(w io.Writer, apexBundleName, apexName, mo fmt.Fprintln(w, "LOCAL_APKCERTS_FILE :=", as.APKCertsFile().String()) fmt.Fprintln(w, "include $(BUILD_SYSTEM)/soong_android_app_set.mk") case nativeSharedLib, nativeExecutable, nativeTest: - fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", fi.Stem()) + fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", fi.stem()) if ccMod, ok := fi.module.(*cc.Module); ok { if ccMod.UnstrippedOutputFile() != nil { fmt.Fprintln(w, "LOCAL_SOONG_UNSTRIPPED_BINARY :=", ccMod.UnstrippedOutputFile().String()) @@ -236,7 +263,7 @@ func (a *apexBundle) androidMkForFiles(w io.Writer, apexBundleName, apexName, mo } fmt.Fprintln(w, "include $(BUILD_SYSTEM)/soong_cc_prebuilt.mk") default: - fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", fi.Stem()) + fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", fi.stem()) if fi.builtFile == a.manifestPbOut && apexType == flattenedApex { if a.primaryApexType { // To install companion files (init_rc, vintf_fragments) diff --git a/apex/apex.go b/apex/apex.go index dff0855a5..a645b06d0 100644 --- a/apex/apex.go +++ b/apex/apex.go @@ -12,6 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +// package apex implements build rules for creating the APEX files which are container for +// lower-level system components. See https://source.android.com/devices/tech/ota/apex package apex import ( @@ -63,57 +65,99 @@ func RegisterPostDepsMutators(ctx android.RegisterMutatorsContext) { } type apexBundleProperties struct { - // Json manifest file describing meta info of this APEX bundle. Default: - // "apex_manifest.json" + // Json manifest file describing meta info of this APEX bundle. Refer to + // system/apex/proto/apex_manifest.proto for the schema. Default: "apex_manifest.json" Manifest *string `android:"path"` - // AndroidManifest.xml file used for the zip container of this APEX bundle. - // If unspecified, a default one is automatically generated. + // AndroidManifest.xml file used for the zip container of this APEX bundle. If unspecified, + // a default one is automatically generated. AndroidManifest *string `android:"path"` - // Canonical name of the APEX bundle. Used to determine the path to the activated APEX on - // device (/apex/). - // If unspecified, defaults to the value of name. + // Canonical name of this APEX bundle. Used to determine the path to the activated APEX on + // device (/apex/). If unspecified, follows the name property. Apex_name *string - // Determines the file contexts file for setting security context to each file in this APEX bundle. - // For platform APEXes, this should points to a file under /system/sepolicy - // Default: /system/sepolicy/apex/_file_contexts. + // Determines the file contexts file for setting the security contexts to files in this APEX + // bundle. For platform APEXes, this should points to a file under /system/sepolicy Default: + // /system/sepolicy/apex/_file_contexts. File_contexts *string `android:"path"` ApexNativeDependencies - // List of java libraries that are embedded inside this APEX bundle + Multilib apexMultilibProperties + + // List of java libraries that are embedded inside this APEX bundle. Java_libs []string - // List of prebuilt files that are embedded inside this APEX bundle + // List of prebuilt files that are embedded inside this APEX bundle. Prebuilts []string - // List of BPF programs inside APEX + // List of BPF programs inside this APEX bundle. Bpfs []string - // Name of the apex_key module that provides the private key to sign APEX + // Name of the apex_key module that provides the private key to sign this APEX bundle. Key *string - // The type of APEX to build. Controls what the APEX payload is. Either - // 'image', 'zip' or 'both'. Default: 'image'. - Payload_type *string - - // The name of a certificate in the default certificate directory, blank to use the default product certificate, - // or an android_app_certificate module name in the form ":module". + // Specifies the certificate and the private key to sign the zip container of this APEX. If + // this is "foo", foo.x509.pem and foo.pk8 under PRODUCT_DEFAULT_DEV_CERTIFICATE are used + // as the certificate and the private key, respectively. If this is ":module", then the + // certificate and the private key are provided from the android_app_certificate module + // named "module". Certificate *string - // Whether this APEX is installable to one of the partitions. Default: true. + // The minimum SDK version that this APEX must support at minimum. This is usually set to + // the SDK version that the APEX was first introduced. + Min_sdk_version *string + + // Whether this APEX is considered updatable or not. When set to true, this will enforce + // additional rules for making sure that the APEX is truly updatable. To be updatable, + // min_sdk_version should be set as well. This will also disable the size optimizations like + // symlinking to the system libs. Default is false. + Updatable *bool + + // Whether this APEX is installable to one of the partitions like system, vendor, etc. + // Default: true. Installable *bool - // For native libraries and binaries, use the vendor variant instead of the core (platform) variant. - // Default is false. + // For native libraries and binaries, use the vendor variant instead of the core (platform) + // variant. Default is false. DO NOT use this for APEXes that are installed to the system or + // system_ext partition. Use_vendor *bool - // For telling the apex to ignore special handling for system libraries such as bionic. Default is false. + // If set true, VNDK libs are considered as stable libs and are not included in this APEX. + // Should be only used in non-system apexes (e.g. vendor: true). Default is false. + Use_vndk_as_stable *bool + + // List of SDKs that are used to build this APEX. A reference to an SDK should be either + // `name#version` or `name` which is an alias for `name#current`. If left empty, + // `platform#current` is implied. This value affects all modules included in this APEX. In + // other words, they are also built with the SDKs specified here. + Uses_sdks []string + + // The type of APEX to build. Controls what the APEX payload is. Either 'image', 'zip' or + // 'both'. When set to image, contents are stored in a filesystem image inside a zip + // container. When set to zip, contents are stored in a zip container directly. This type is + // mostly for host-side debugging. When set to both, the two types are both built. Default + // is 'image'. + Payload_type *string + + // The type of filesystem to use when the payload_type is 'image'. Either 'ext4' or 'f2fs'. + // Default 'ext4'. + Payload_fs_type *string + + // For telling the APEX to ignore special handling for system libraries such as bionic. + // Default is false. Ignore_system_library_special_case *bool - Multilib apexMultilibProperties + // Whenever apex_payload.img of the APEX should include dm-verity hashtree. Should be only + // used in tests. + Test_only_no_hashtree *bool + + // Whenever apex_payload.img of the APEX should not be dm-verity signed. Should be only + // used in tests. + Test_only_unsigned_payload *bool + + IsCoverageVariant bool `blueprint:"mutated"` // List of sanitizer names that this APEX is enabled for SanitizerNames []string `blueprint:"mutated"` @@ -122,57 +166,23 @@ type apexBundleProperties struct { HideFromMake bool `blueprint:"mutated"` - // package format of this apex variant; could be non-flattened, flattened, or zip. - // imageApex, zipApex or flattened + // Internal package method for this APEX. When payload_type is image, this can be either + // imageApex or flattenedApex depending on Config.FlattenApex(). When payload_type is zip, + // this becomes zipApex. ApexType apexPackaging `blueprint:"mutated"` - - // List of SDKs that are used to build this APEX. A reference to an SDK should be either - // `name#version` or `name` which is an alias for `name#current`. If left empty, `platform#current` - // is implied. This value affects all modules included in this APEX. In other words, they are - // also built with the SDKs specified here. - Uses_sdks []string - - // Whenever apex_payload.img of the APEX should include dm-verity hashtree. - // Should be only used in tests#. - Test_only_no_hashtree *bool - - // Whenever apex_payload.img of the APEX should not be dm-verity signed. - // Should be only used in tests#. - Test_only_unsigned_payload *bool - - IsCoverageVariant bool `blueprint:"mutated"` - - // Whether this APEX is considered updatable or not. When set to true, this will enforce additional - // rules for making sure that the APEX is truly updatable. - // - To be updatable, min_sdk_version should be set as well - // This will also disable the size optimizations like symlinking to the system libs. - // Default is false. - Updatable *bool - - // The minimum SDK version that this apex must be compatibile with. - Min_sdk_version *string - - // If set true, VNDK libs are considered as stable libs and are not included in this apex. - // Should be only used in non-system apexes (e.g. vendor: true). - // Default is false. - Use_vndk_as_stable *bool - - // The type of filesystem to use for an image apex. Either 'ext4' or 'f2fs'. - // Default 'ext4'. - Payload_fs_type *string } type ApexNativeDependencies struct { - // List of native libraries + // List of native libraries that are embedded inside this APEX. Native_shared_libs []string - // List of JNI libraries + // List of JNI libraries that are embedded inside this APEX. Jni_libs []string - // List of native executables + // List of native executables that are embedded inside this APEX. Binaries []string - // List of native tests + // List of native tests that are embedded inside this APEX. Tests []string } @@ -217,25 +227,26 @@ type apexTargetBundleProperties struct { } } +// These properties can be used in override_apex to override the corresponding properties in the +// base apex. type overridableProperties struct { - // List of APKs to package inside APEX + // List of APKs that are embedded inside this APEX. Apps []string - // List of runtime resource overlays (RROs) inside APEX + // List of runtime resource overlays (RROs) that are embedded inside this APEX. Rros []string - // Names of modules to be overridden. Listed modules can only be other binaries - // (in Make or Soong). - // This does not completely prevent installation of the overridden binaries, but if both - // binaries would be installed by default (in PRODUCT_PACKAGES) the other binary will be removed - // from PRODUCT_PACKAGES. + // Names of modules to be overridden. Listed modules can only be other binaries (in Make or + // Soong). This does not completely prevent installation of the overridden binaries, but if + // both binaries would be installed by default (in PRODUCT_PACKAGES) the other binary will + // be removed from PRODUCT_PACKAGES. Overrides []string - // Logging Parent value + // Logging parent value. Logging_parent string - // Apex Container Package Name. - // Override value for attribute package:name in AndroidManifest.xml + // Apex Container package name. Override value for attribute package:name in + // AndroidManifest.xml Package_name string // A txt file containing list of files that are allowed to be included in this APEX. @@ -243,187 +254,202 @@ type overridableProperties struct { } type apexBundle struct { + // Inherited structs android.ModuleBase android.DefaultableModuleBase android.OverridableModuleBase android.SdkBase + // Properties properties apexBundleProperties targetProperties apexTargetBundleProperties overridableProperties overridableProperties + vndkProperties apexVndkProperties // only for apex_vndk modules - // specific to apex_vndk modules - vndkProperties apexVndkProperties - - bundleModuleFile android.WritablePath - outputFile android.WritablePath - installDir android.InstallPath - - prebuiltFileToDelete string + /////////////////////////////////////////////////////////////////////////////////////////// + // Inputs + // Keys for apex_paylaod.img public_key_file android.Path private_key_file android.Path + // Cert/priv-key for the zip container container_certificate_file android.Path container_private_key_file android.Path - fileContexts android.WritablePath + // Flags for special variants of APEX + testApex bool + vndkApex bool + artApex bool - // list of files to be included in this apex - filesInfo []apexFile - - // list of module names that should be installed along with this APEX - requiredDeps []string - - // list of module names that this APEX is including (to be shown via *-deps-info target) - android.ApexBundleDepsInfo - - testApex bool - vndkApex bool - artApex bool + // Tells whether this variant of the APEX bundle is the primary one or not. Only the primary + // one gets installed to the device. primaryApexType bool - manifestJsonOut android.WritablePath - manifestPbOut android.WritablePath - - // list of commands to create symlinks for backward compatibility. - // these commands will be attached as LOCAL_POST_INSTALL_CMD to - // apex package itself(for unflattened build) or apex_manifest(for flattened build) - // so that compat symlinks are always installed regardless of TARGET_FLATTEN_APEX setting. - compatSymlinks []string - - // Suffix of module name in Android.mk - // ".flattened", ".apex", ".zipapex", or "" + // Suffix of module name in Android.mk ".flattened", ".apex", ".zipapex", or "" suffix string - installedFilesFile android.WritablePath + // File system type of apex_payload.img + payloadFsType fsType - // Whether to create symlink to the system file instead of having a file - // inside the apex or not + // Whether to create symlink to the system file instead of having a file inside the apex or + // not linkToSystemLib bool + // List of files to be included in this APEX. This is filled in the first part of + // GenerateAndroidBuildActions. + filesInfo []apexFile + + // List of other module names that should be installed when this APEX gets installed. + requiredDeps []string + + /////////////////////////////////////////////////////////////////////////////////////////// + // Outputs (final and intermediates) + + // Processed apex manifest in JSONson format (for Q) + manifestJsonOut android.WritablePath + + // Processed apex manifest in PB format (for R+) + manifestPbOut android.WritablePath + + // Processed file_contexts files + fileContexts android.WritablePath + // Struct holding the merged notice file paths in different formats mergedNotices android.NoticeOutputs + // The built APEX file. This is the main product. + outputFile android.WritablePath + + // The built APEX file in app bundle format. This file is not directly installed to the + // device. For an APEX, multiple app bundles are created each of which is for a specific ABI + // like arm, arm64, x86, etc. Then they are processed again (outside of the Android build + // system) to be merged into a single app bundle file that Play accepts. See + // vendor/google/build/build_unbundled_mainline_module.sh for more detail. + bundleModuleFile android.WritablePath + + // Target path to install this APEX. Usually out/target/product///apex. + installDir android.InstallPath + + // List of commands to create symlinks for backward compatibility. These commands will be + // attached as LOCAL_POST_INSTALL_CMD to apex package itself (for unflattened build) or + // apex_manifest (for flattened build) so that compat symlinks are always installed + // regardless of TARGET_FLATTEN_APEX setting. + compatSymlinks []string + + // Text file having the list of individual files that are included in this APEX. Used for + // debugging purpose. + installedFilesFile android.WritablePath + + // List of module names that this APEX is including (to be shown via *-deps-info target). + // Used for debugging purpose. + android.ApexBundleDepsInfo + // Optional list of lint report zip files for apexes that contain java or app modules lintReports android.Paths - payloadFsType fsType + prebuiltFileToDelete string distFiles android.TaggedDistFiles } +// apexFileClass represents a type of file that can be included in APEX. type apexFileClass int const ( - etc apexFileClass = iota - nativeSharedLib - nativeExecutable - shBinary - pyBinary + app apexFileClass = iota + appSet + etc goBinary javaSharedLib + nativeExecutable + nativeSharedLib nativeTest - app - appSet + pyBinary + shBinary ) -func (class apexFileClass) NameInMake() string { - switch class { - case etc: - return "ETC" - case nativeSharedLib: - return "SHARED_LIBRARIES" - case nativeExecutable, shBinary, pyBinary, goBinary: - return "EXECUTABLES" - case javaSharedLib: - return "JAVA_LIBRARIES" - case nativeTest: - return "NATIVE_TESTS" - case app, appSet: - // b/142537672 Why isn't this APP? We want to have full control over - // the paths and file names of the apk file under the flattend APEX. - // If this is set to APP, then the paths and file names are modified - // by the Make build system. For example, it is installed to - // /system/apex//app//./ instead of - // /system/apex//app/ because the build system automatically - // appends module name (which is . to the path. - return "ETC" - default: - panic(fmt.Errorf("unknown class %d", class)) - } -} - -// apexFile represents a file in an APEX bundle +// apexFile represents a file in an APEX bundle. This is created during the first half of +// GenerateAndroidBuildActions by traversing the dependencies of the APEX. Then in the second half +// of the function, this is used to create commands that copies the files into a staging directory, +// where they are packaged into the APEX file. This struct is also used for creating Make modules +// for each of the files in case when the APEX is flattened. type apexFile struct { - builtFile android.Path - stem string - // Module name of `module` in AndroidMk. Note the generated AndroidMk module for - // apexFile is named something like .[] - androidMkModuleName string - installDir string - class apexFileClass - module android.Module - // list of symlinks that will be created in installDir that point to this apexFile - symlinks []string - dataPaths []android.DataPath - transitiveDep bool - moduleDir string + // buildFile is put in the installDir inside the APEX. + builtFile android.Path + noticeFiles android.Paths + installDir string + customStem string + symlinks []string // additional symlinks - requiredModuleNames []string - targetRequiredModuleNames []string - hostRequiredModuleNames []string + // Info for Android.mk Module name of `module` in AndroidMk. Note the generated AndroidMk + // module for apexFile is named something like .[] + androidMkModuleName string // becomes LOCAL_MODULE + class apexFileClass // becomes LOCAL_MODULE_CLASS + moduleDir string // becomes LOCAL_PATH + requiredModuleNames []string // becomes LOCAL_REQUIRED_MODULES + targetRequiredModuleNames []string // becomes LOCAL_TARGET_REQUIRED_MODULES + hostRequiredModuleNames []string // becomes LOCAL_HOST_REQUIRED_MODULES + dataPaths []android.DataPath // becomes LOCAL_TEST_DATA jacocoReportClassesFile android.Path // only for javalibs and apps lintDepSets java.LintDepSets // only for javalibs and apps certificate java.Certificate // only for apps overriddenPackageName string // only for apps - isJniLib bool + transitiveDep bool + isJniLib bool - noticeFiles android.Paths + // TODO(jiyong): remove this + module android.Module } +// TODO(jiyong): shorten the arglist using an option struct func newApexFile(ctx android.BaseModuleContext, builtFile android.Path, androidMkModuleName string, installDir string, class apexFileClass, module android.Module) apexFile { ret := apexFile{ builtFile: builtFile, - androidMkModuleName: androidMkModuleName, installDir: installDir, + androidMkModuleName: androidMkModuleName, class: class, module: module, } if module != nil { + ret.noticeFiles = module.NoticeFiles() ret.moduleDir = ctx.OtherModuleDir(module) ret.requiredModuleNames = module.RequiredModuleNames() ret.targetRequiredModuleNames = module.TargetRequiredModuleNames() ret.hostRequiredModuleNames = module.HostRequiredModuleNames() - ret.noticeFiles = module.NoticeFiles() } return ret } -func (af *apexFile) Ok() bool { +func (af *apexFile) ok() bool { return af.builtFile != nil && af.builtFile.String() != "" } +// apexRelativePath returns the relative path of the given path from the install directory of this +// apexFile. +// TODO(jiyong): rename this func (af *apexFile) apexRelativePath(path string) string { return filepath.Join(af.installDir, path) } -// Path() returns path of this apex file relative to the APEX root -func (af *apexFile) Path() string { - return af.apexRelativePath(af.Stem()) +// path returns path of this apex file relative to the APEX root +func (af *apexFile) path() string { + return af.apexRelativePath(af.stem()) } -func (af *apexFile) Stem() string { - if af.stem != "" { - return af.stem +// stem returns the base filename of this apex file +func (af *apexFile) stem() string { + if af.customStem != "" { + return af.customStem } return af.builtFile.Base() } -// SymlinkPaths() returns paths of the symlinks (if any) relative to the APEX root -func (af *apexFile) SymlinkPaths() []string { +// symlinkPaths returns paths of the symlinks (if any) relative to the APEX root +func (af *apexFile) symlinkPaths() []string { var ret []string for _, symlink := range af.symlinks { ret = append(ret, af.apexRelativePath(symlink)) @@ -431,7 +457,9 @@ func (af *apexFile) SymlinkPaths() []string { return ret } -func (af *apexFile) AvailableToPlatform() bool { +// availableToPlatform tests whether this apexFile is from a module that can be installed to the +// platform. +func (af *apexFile) availableToPlatform() bool { if af.module == nil { return false } @@ -441,37 +469,70 @@ func (af *apexFile) AvailableToPlatform() bool { return false } -func addDependenciesForNativeModules(ctx android.BottomUpMutatorContext, - nativeModules ApexNativeDependencies, - target android.Target, imageVariation string) { - // Use *FarVariation* to be able to depend on modules having - // conflicting variations with this module. This is required since - // arch variant of an APEX bundle is 'common' but it is 'arm' or 'arm64' - // for native shared libs. +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Mutators +// +// Brief description about mutators for APEX. The following three mutators are the most important +// ones. +// +// 1) DepsMutator: from the properties like native_shared_libs, java_libs, etc., modules are added +// to the (direct) dependencies of this APEX bundle. +// +// 2) apexDepsMutator: this is a post-deps mutator, so runs after DepsMutator. Its goal is to +// collect modules that are direct and transitive dependencies of each APEX bundle. The collected +// modules are marked as being included in the APEX via BuildForApex(). +// +// 3) apexMutator: this is a post-deps mutator that runs after apexDepsMutator. For each module that +// are marked by the apexDepsMutator, apex variations are created using CreateApexVariations(). +type dependencyTag struct { + blueprint.BaseDependencyTag + name string + + // Determines if the dependent will be part of the APEX payload. Can be false for the + // dependencies to the signing key module, etc. + payload bool +} + +var ( + androidAppTag = dependencyTag{name: "androidApp", payload: true} + bpfTag = dependencyTag{name: "bpf", payload: true} + certificateTag = dependencyTag{name: "certificate"} + executableTag = dependencyTag{name: "executable", payload: true} + javaLibTag = dependencyTag{name: "javaLib", payload: true} + jniLibTag = dependencyTag{name: "jniLib", payload: true} + keyTag = dependencyTag{name: "key"} + prebuiltTag = dependencyTag{name: "prebuilt", payload: true} + rroTag = dependencyTag{name: "rro", payload: true} + sharedLibTag = dependencyTag{name: "sharedLib", payload: true} + testForTag = dependencyTag{name: "test for"} + testTag = dependencyTag{name: "test", payload: true} +) + +// TODO(jiyong): shorten this function signature +func addDependenciesForNativeModules(ctx android.BottomUpMutatorContext, nativeModules ApexNativeDependencies, target android.Target, imageVariation string) { binVariations := target.Variations() - libVariations := append(target.Variations(), - blueprint.Variation{Mutator: "link", Variation: "shared"}) + libVariations := append(target.Variations(), blueprint.Variation{Mutator: "link", Variation: "shared"}) if ctx.Device() { - binVariations = append(binVariations, - blueprint.Variation{Mutator: "image", Variation: imageVariation}) + binVariations = append(binVariations, blueprint.Variation{Mutator: "image", Variation: imageVariation}) libVariations = append(libVariations, blueprint.Variation{Mutator: "image", Variation: imageVariation}, - blueprint.Variation{Mutator: "version", Variation: ""}) // "" is the non-stub variant + blueprint.Variation{Mutator: "version", Variation: ""}, // "" is the non-stub variant + ) } - ctx.AddFarVariationDependencies(libVariations, sharedLibTag, nativeModules.Native_shared_libs...) - - ctx.AddFarVariationDependencies(libVariations, jniLibTag, nativeModules.Jni_libs...) - + // Use *FarVariation* to be able to depend on modules having conflicting variations with + // this module. This is required since arch variant of an APEX bundle is 'common' but it is + // 'arm' or 'arm64' for native shared libs. ctx.AddFarVariationDependencies(binVariations, executableTag, nativeModules.Binaries...) - ctx.AddFarVariationDependencies(binVariations, testTag, nativeModules.Tests...) + ctx.AddFarVariationDependencies(libVariations, jniLibTag, nativeModules.Jni_libs...) + ctx.AddFarVariationDependencies(libVariations, sharedLibTag, nativeModules.Native_shared_libs...) } func (a *apexBundle) combineProperties(ctx android.BottomUpMutatorContext) { - if ctx.Os().Class == android.Device { + if ctx.Device() { proptools.AppendProperties(&a.properties.Multilib, &a.targetProperties.Target.Android.Multilib, nil) } else { proptools.AppendProperties(&a.properties.Multilib, &a.targetProperties.Target.Host.Multilib, nil) @@ -483,34 +544,46 @@ func (a *apexBundle) combineProperties(ctx android.BottomUpMutatorContext) { } } -type dependencyTag struct { - blueprint.BaseDependencyTag - name string - - // determines if the dependent will be part of the APEX payload - payload bool -} - -var ( - sharedLibTag = dependencyTag{name: "sharedLib", payload: true} - jniLibTag = dependencyTag{name: "jniLib", payload: true} - executableTag = dependencyTag{name: "executable", payload: true} - javaLibTag = dependencyTag{name: "javaLib", payload: true} - prebuiltTag = dependencyTag{name: "prebuilt", payload: true} - testTag = dependencyTag{name: "test", payload: true} - keyTag = dependencyTag{name: "key"} - certificateTag = dependencyTag{name: "certificate"} - androidAppTag = dependencyTag{name: "androidApp", payload: true} - rroTag = dependencyTag{name: "rro", payload: true} - bpfTag = dependencyTag{name: "bpf", payload: true} - testForTag = dependencyTag{name: "test for"} -) - -func (a *apexBundle) DepsMutator(ctx android.BottomUpMutatorContext) { - if proptools.Bool(a.properties.Use_vendor) && !android.InList(a.Name(), useVendorAllowList(ctx.Config())) { - ctx.PropertyErrorf("use_vendor", "not allowed to set use_vendor: true") +// getImageVariation returns the image variant name for this apexBundle. In most cases, it's simply +// android.CoreVariation, but gets complicated for the vendor APEXes and the VNDK APEX. +func (a *apexBundle) getImageVariation(ctx android.BottomUpMutatorContext) string { + deviceConfig := ctx.DeviceConfig() + if a.vndkApex { + return cc.VendorVariationPrefix + a.vndkVersion(deviceConfig) } + var prefix string + var vndkVersion string + if deviceConfig.VndkVersion() != "" { + if proptools.Bool(a.properties.Use_vendor) { + prefix = cc.VendorVariationPrefix + vndkVersion = deviceConfig.PlatformVndkVersion() + } else if a.SocSpecific() || a.DeviceSpecific() { + prefix = cc.VendorVariationPrefix + vndkVersion = deviceConfig.VndkVersion() + } else if a.ProductSpecific() { + prefix = cc.ProductVariationPrefix + vndkVersion = deviceConfig.ProductVndkVersion() + } + } + if vndkVersion == "current" { + vndkVersion = deviceConfig.PlatformVndkVersion() + } + if vndkVersion != "" { + return prefix + vndkVersion + } + + return android.CoreVariation // The usual case +} + +func (a *apexBundle) DepsMutator(ctx android.BottomUpMutatorContext) { + // TODO(jiyong): move this kind of checks to GenerateAndroidBuildActions? + checkUseVendorProperty(ctx, a) + + // apexBundle is a multi-arch targets module. Arch variant of apexBundle is set to 'common'. + // arch-specific targets are enabled by the compile_multilib setting of the apex bundle. For + // each target os/architectures, appropriate dependencies are selected by their + // target..multilib. groups and are added as (direct) dependencies. targets := ctx.MultiTargets() config := ctx.DeviceConfig() imageVariation := a.getImageVariation(ctx) @@ -524,80 +597,56 @@ func (a *apexBundle) DepsMutator(ctx android.BottomUpMutatorContext) { } } for i, target := range targets { + // Don't include artifacts for the host cross targets because there is no way for us + // to run those artifacts natively on host if target.HostCross { - // Don't include artifats for the host cross targets because there is no way - // for us to run those artifacts natively on host continue } - // When multilib.* is omitted for native_shared_libs/jni_libs/tests, it implies - // multilib.both - addDependenciesForNativeModules(ctx, - ApexNativeDependencies{ - Native_shared_libs: a.properties.Native_shared_libs, - Tests: a.properties.Tests, - Jni_libs: a.properties.Jni_libs, - Binaries: nil, - }, - target, imageVariation) + var depsList []ApexNativeDependencies - // Add native modules targetting both ABIs - addDependenciesForNativeModules(ctx, - a.properties.Multilib.Both, - target, - imageVariation) + // Add native modules targeting both ABIs. When multilib.* is omitted for + // native_shared_libs/jni_libs/tests, it implies multilib.both + depsList = append(depsList, a.properties.Multilib.Both) + depsList = append(depsList, ApexNativeDependencies{ + Native_shared_libs: a.properties.Native_shared_libs, + Tests: a.properties.Tests, + Jni_libs: a.properties.Jni_libs, + Binaries: nil, + }) + // Add native modules targeting the first ABI When multilib.* is omitted for + // binaries, it implies multilib.first isPrimaryAbi := i == 0 if isPrimaryAbi { - // When multilib.* is omitted for binaries, it implies - // multilib.first - addDependenciesForNativeModules(ctx, - ApexNativeDependencies{ - Native_shared_libs: nil, - Tests: nil, - Jni_libs: nil, - Binaries: a.properties.Binaries, - }, - target, imageVariation) - - // Add native modules targetting the first ABI - addDependenciesForNativeModules(ctx, - a.properties.Multilib.First, - target, - imageVariation) + depsList = append(depsList, a.properties.Multilib.First) + depsList = append(depsList, ApexNativeDependencies{ + Native_shared_libs: nil, + Tests: nil, + Jni_libs: nil, + Binaries: a.properties.Binaries, + }) } + // Add native modules targeting either 32-bit or 64-bit ABI switch target.Arch.ArchType.Multilib { case "lib32": - // Add native modules targetting 32-bit ABI - addDependenciesForNativeModules(ctx, - a.properties.Multilib.Lib32, - target, - imageVariation) - - addDependenciesForNativeModules(ctx, - a.properties.Multilib.Prefer32, - target, - imageVariation) + depsList = append(depsList, a.properties.Multilib.Lib32) + depsList = append(depsList, a.properties.Multilib.Prefer32) case "lib64": - // Add native modules targetting 64-bit ABI - addDependenciesForNativeModules(ctx, - a.properties.Multilib.Lib64, - target, - imageVariation) - + depsList = append(depsList, a.properties.Multilib.Lib64) if !has32BitTarget { - addDependenciesForNativeModules(ctx, - a.properties.Multilib.Prefer32, - target, - imageVariation) + depsList = append(depsList, a.properties.Multilib.Prefer32) } } + + for _, d := range depsList { + addDependenciesForNativeModules(ctx, d, target, imageVariation) + } } - // For prebuilt_etc, use the first variant (64 on 64/32bit device, - // 32 on 32bit device) regardless of the TARGET_PREFER_* setting. - // b/144532908 + // For prebuilt_etc, use the first variant (64 on 64/32bit device, 32 on 32bit device) + // regardless of the TARGET_PREFER_* setting. See b/144532908 archForPrebuiltEtc := config.Arches()[0] for _, arch := range config.Arches() { // Prefer 64-bit arch if there is any @@ -611,20 +660,19 @@ func (a *apexBundle) DepsMutator(ctx android.BottomUpMutatorContext) { {Mutator: "arch", Variation: archForPrebuiltEtc.String()}, }, prebuiltTag, a.properties.Prebuilts...) - ctx.AddFarVariationDependencies(ctx.Config().AndroidCommonTarget.Variations(), - javaLibTag, a.properties.Java_libs...) - - ctx.AddFarVariationDependencies(ctx.Config().AndroidCommonTarget.Variations(), - bpfTag, a.properties.Bpfs...) + // Common-arch dependencies come next + commonVariation := ctx.Config().AndroidCommonTarget.Variations() + ctx.AddFarVariationDependencies(commonVariation, javaLibTag, a.properties.Java_libs...) + ctx.AddFarVariationDependencies(commonVariation, bpfTag, a.properties.Bpfs...) // With EMMA_INSTRUMENT_FRAMEWORK=true the ART boot image includes jacoco library. if a.artApex && ctx.Config().IsEnvTrue("EMMA_INSTRUMENT_FRAMEWORK") { - ctx.AddFarVariationDependencies(ctx.Config().AndroidCommonTarget.Variations(), - javaLibTag, "jacocoagent") + ctx.AddFarVariationDependencies(commonVariation, javaLibTag, "jacocoagent") } + // Dependencies for signing if String(a.properties.Key) == "" { - ctx.ModuleErrorf("key is missing") + ctx.PropertyErrorf("key", "missing") return } ctx.AddDependency(ctx.Module(), keyTag, String(a.properties.Key)) @@ -632,8 +680,13 @@ func (a *apexBundle) DepsMutator(ctx android.BottomUpMutatorContext) { cert := android.SrcIsModule(a.getCertString(ctx)) if cert != "" { ctx.AddDependency(ctx.Module(), certificateTag, cert) + // empty cert is not an error. Cert and private keys will be directly found under + // PRODUCT_DEFAULT_DEV_CERTIFICATE } + // Marks that this APEX (in fact all the modules in it) has to be built with the given SDKs. + // This field currently isn't used. + // TODO(jiyong): consider dropping this feature // TODO(jiyong): ensure that all apexes are with non-empty uses_sdks if len(a.properties.Uses_sdks) > 0 { sdkRefs := []android.SdkRef{} @@ -645,14 +698,15 @@ func (a *apexBundle) DepsMutator(ctx android.BottomUpMutatorContext) { } } +// DepsMutator for the overridden properties. func (a *apexBundle) OverridablePropertiesDepsMutator(ctx android.BottomUpMutatorContext) { if a.overridableProperties.Allowed_files != nil { android.ExtractSourceDeps(ctx, a.overridableProperties.Allowed_files) } - ctx.AddFarVariationDependencies(ctx.Config().AndroidCommonTarget.Variations(), - androidAppTag, a.overridableProperties.Apps...) - ctx.AddFarVariationDependencies(ctx.Config().AndroidCommonTarget.Variations(), - rroTag, a.overridableProperties.Rros...) + + commonVariation := ctx.Config().AndroidCommonTarget.Variations() + ctx.AddFarVariationDependencies(commonVariation, androidAppTag, a.overridableProperties.Apps...) + ctx.AddFarVariationDependencies(commonVariation, rroTag, a.overridableProperties.Rros...) } type ApexBundleInfo struct { @@ -661,17 +715,34 @@ type ApexBundleInfo struct { var ApexBundleInfoProvider = blueprint.NewMutatorProvider(ApexBundleInfo{}, "apex_deps") -// Mark the direct and transitive dependencies of apex bundles so that they -// can be built for the apex bundles. +// apexDepsMutator is responsible for collecting modules that need to have apex variants. They are +// identified by doing a graph walk starting from an apexBundle. Basically, all the (direct and +// indirect) dependencies are collected. But a few types of modules that shouldn't be included in +// the apexBundle (e.g. stub libraries) are not collected. Note that a single module can be depended +// on by multiple apexBundles. In that case, the module is collected for all of the apexBundles. func apexDepsMutator(mctx android.TopDownMutatorContext) { if !mctx.Module().Enabled() { return } + a, ok := mctx.Module().(*apexBundle) - if !ok || a.vndkApex { + if !ok { return } + // The VNDK APEX is special. For the APEX, the membership is described in a very different + // way. There is no dependency from the VNDK APEX to the VNDK libraries. Instead, VNDK + // libraries are self-identified by their vndk.enabled properties. There is no need to run + // this mutator for the APEX as nothing will be collected. So, let's return fast. + if a.vndkApex { + return + } + + // Special casing for APEXes on non-system (e.g., vendor, odm, etc.) partitions. They are + // provided with a property named use_vndk_as_stable, which when set to true doesn't collect + // VNDK libraries as transitive dependencies. This option is useful for reducing the size of + // the non-system APEXes because the VNDK libraries won't be included (and duped) in the + // APEX, but shared across APEXes via the VNDK APEX. useVndk := a.SocSpecific() || a.DeviceSpecific() || (a.ProductSpecific() && mctx.Config().EnforceProductPartitionInterface()) excludeVndkLibs := useVndk && proptools.Bool(a.properties.Use_vndk_as_stable) if !useVndk && proptools.Bool(a.properties.Use_vndk_as_stable) { @@ -679,8 +750,6 @@ func apexDepsMutator(mctx android.TopDownMutatorContext) { return } - contents := make(map[string]android.ApexMembership) - continueApexDepsWalk := func(child, parent android.Module) bool { am, ok := child.(android.ApexModule) if !ok || !am.CanHaveApexVariants() { @@ -694,26 +763,33 @@ func apexDepsMutator(mctx android.TopDownMutatorContext) { return false } } + // By default, all the transitive dependencies are collected, unless filtered out + // above. return true } + // Records whether a certain module is included in this apexBundle via direct dependency or + // inndirect dependency. + contents := make(map[string]android.ApexMembership) mctx.WalkDeps(func(child, parent android.Module) bool { if !continueApexDepsWalk(child, parent) { return false } - - depName := mctx.OtherModuleName(child) // If the parent is apexBundle, this child is directly depended. _, directDep := parent.(*apexBundle) + depName := mctx.OtherModuleName(child) contents[depName] = contents[depName].Add(directDep) return true }) + // The membership information is saved for later access apexContents := android.NewApexContents(contents) mctx.SetProvider(ApexBundleInfoProvider, ApexBundleInfo{ Contents: apexContents, }) + // This is the main part of this mutator. Mark the collected dependencies that they need to + // be built for this apexBundle. apexInfo := android.ApexInfo{ ApexVariationName: mctx.ModuleName(), MinSdkVersionStr: a.minSdkVersion(mctx).String(), @@ -722,34 +798,34 @@ func apexDepsMutator(mctx android.TopDownMutatorContext) { InApexes: []string{mctx.ModuleName()}, ApexContents: []*android.ApexContents{apexContents}, } - mctx.WalkDeps(func(child, parent android.Module) bool { if !continueApexDepsWalk(child, parent) { return false } - - child.(android.ApexModule).BuildForApex(apexInfo) + child.(android.ApexModule).BuildForApex(apexInfo) // leave a mark! return true }) } +// apexUniqueVariationsMutator checks if any dependencies use unique apex variations. If so, use +// unique apex variations for this module. See android/apex.go for more about unique apex variant. +// TODO(jiyong): move this to android/apex.go? func apexUniqueVariationsMutator(mctx android.BottomUpMutatorContext) { if !mctx.Module().Enabled() { return } if am, ok := mctx.Module().(android.ApexModule); ok { - // Check if any dependencies use unique apex variations. If so, use unique apex variations - // for this module. android.UpdateUniqueApexVariationsForDeps(mctx, am) } } +// apexTestForDepsMutator checks if this module is a test for an apex. If so, add a dependency on +// the apex in order to retrieve its contents later. +// TODO(jiyong): move this to android/apex.go? func apexTestForDepsMutator(mctx android.BottomUpMutatorContext) { if !mctx.Module().Enabled() { return } - // Check if this module is a test for an apex. If so, add a dependency on the apex - // in order to retrieve its contents later. if am, ok := mctx.Module().(android.ApexModule); ok { if testFor := am.TestFor(); len(testFor) > 0 { mctx.AddFarVariationDependencies([]blueprint.Variation{ @@ -760,11 +836,11 @@ func apexTestForDepsMutator(mctx android.BottomUpMutatorContext) { } } +// TODO(jiyong): move this to android/apex.go? func apexTestForMutator(mctx android.BottomUpMutatorContext) { if !mctx.Module().Enabled() { return } - if _, ok := mctx.Module().(android.ApexModule); ok { var contents []*android.ApexContents for _, testFor := range mctx.GetDirectDepsWithTag(testForTag) { @@ -777,69 +853,70 @@ func apexTestForMutator(mctx android.BottomUpMutatorContext) { } } -// mark if a module cannot be available to platform. A module cannot be available -// to platform if 1) it is explicitly marked as not available (i.e. "//apex_available:platform" -// is absent) or 2) it depends on another module that isn't (or can't be) available to platform +// markPlatformAvailability marks whether or not a module can be available to platform. A module +// cannot be available to platform if 1) it is explicitly marked as not available (i.e. +// "//apex_available:platform" is absent) or 2) it depends on another module that isn't (or can't +// be) available to platform +// TODO(jiyong): move this to android/apex.go? func markPlatformAvailability(mctx android.BottomUpMutatorContext) { // Host and recovery are not considered as platform if mctx.Host() || mctx.Module().InstallInRecovery() { return } - if am, ok := mctx.Module().(android.ApexModule); ok { - availableToPlatform := am.AvailableFor(android.AvailableToPlatform) + am, ok := mctx.Module().(android.ApexModule) + if !ok { + return + } - // If any of the dep is not available to platform, this module is also considered - // as being not available to platform even if it has "//apex_available:platform" - mctx.VisitDirectDeps(func(child android.Module) { - if !am.DepIsInSameApex(mctx, child) { - // if the dependency crosses apex boundary, don't consider it - return - } - if dep, ok := child.(android.ApexModule); ok && dep.NotAvailableForPlatform() { - availableToPlatform = false - // TODO(b/154889534) trigger an error when 'am' has "//apex_available:platform" - } - }) + availableToPlatform := am.AvailableFor(android.AvailableToPlatform) - // Exception 1: stub libraries and native bridge libraries are always available to platform - if cc, ok := mctx.Module().(*cc.Module); ok && - (cc.IsStubs() || cc.Target().NativeBridge == android.NativeBridgeEnabled) { - availableToPlatform = true + // If any of the dep is not available to platform, this module is also considered as being + // not available to platform even if it has "//apex_available:platform" + mctx.VisitDirectDeps(func(child android.Module) { + if !am.DepIsInSameApex(mctx, child) { + // if the dependency crosses apex boundary, don't consider it + return } - - // Exception 2: bootstrap bionic libraries are also always available to platform - if cc.InstallToBootstrap(mctx.ModuleName(), mctx.Config()) { - availableToPlatform = true + if dep, ok := child.(android.ApexModule); ok && dep.NotAvailableForPlatform() { + availableToPlatform = false + // TODO(b/154889534) trigger an error when 'am' has + // "//apex_available:platform" } + }) - if !availableToPlatform { - am.SetNotAvailableForPlatform() - } + // Exception 1: stub libraries and native bridge libraries are always available to platform + if cc, ok := mctx.Module().(*cc.Module); ok && + (cc.IsStubs() || cc.Target().NativeBridge == android.NativeBridgeEnabled) { + availableToPlatform = true + } + + // Exception 2: bootstrap bionic libraries are also always available to platform + if cc.InstallToBootstrap(mctx.ModuleName(), mctx.Config()) { + availableToPlatform = true + } + + if !availableToPlatform { + am.SetNotAvailableForPlatform() } } -// If a module in an APEX depends on a module from an SDK then it needs an APEX -// specific variant created for it. Refer to sdk.sdkDepsReplaceMutator. -func inAnySdk(module android.Module) bool { - if sa, ok := module.(android.SdkAware); ok { - return sa.IsInAnySdk() - } - - return false -} - -// Create apex variations if a module is included in APEX(s). +// apexMutator visits each module and creates apex variations if the module was marked in the +// previous run of apexDepsMutator. func apexMutator(mctx android.BottomUpMutatorContext) { if !mctx.Module().Enabled() { return } + // This is the usual path. if am, ok := mctx.Module().(android.ApexModule); ok && am.CanHaveApexVariants() { android.CreateApexVariations(mctx, am) - } else if a, ok := mctx.Module().(*apexBundle); ok && !a.vndkApex { - // apex bundle itself is mutated so that it and its modules have same - // apex variant. + return + } + + // apexBundle itself is mutated so that it and its dependencies have the same apex variant. + // TODO(jiyong): document the reason why the VNDK APEX is an exception here. + if a, ok := mctx.Module().(*apexBundle); ok && !a.vndkApex { apexBundleName := mctx.ModuleName() mctx.CreateVariations(apexBundleName) } else if o, ok := mctx.Module().(*OverrideApex); ok { @@ -850,9 +927,10 @@ func apexMutator(mctx android.BottomUpMutatorContext) { } mctx.CreateVariations(apexBundleName) } - } +// See android.UpdateDirectlyInAnyApex +// TODO(jiyong): move this to android/apex.go? func apexDirectlyInAnyMutator(mctx android.BottomUpMutatorContext) { if !mctx.Module().Enabled() { return @@ -862,19 +940,32 @@ func apexDirectlyInAnyMutator(mctx android.BottomUpMutatorContext) { } } +// apexPackaging represents a specific packaging method for an APEX. type apexPackaging int const ( + // imageApex is a packaging method where contents are included in a filesystem image which + // is then included in a zip container. This is the most typical way of packaging. imageApex apexPackaging = iota + + // zipApex is a packaging method where contents are directly included in the zip container. + // This is used for host-side testing - because the contents are easily accessible by + // unzipping the container. zipApex + + // flattendApex is a packaging method where contents are not included in the APEX file, but + // installed to /apex/ directory on the device. This packaging method is used for + // old devices where the filesystem-based APEX file can't be supported. flattenedApex ) const ( + // File extensions of an APEX for different packaging methods imageApexSuffix = ".apex" zipApexSuffix = ".zipapex" flattenedSuffix = ".flattened" + // variant names each of which is for a packaging method imageApexType = "image" zipApexType = "zip" flattenedApexType = "flattened" @@ -906,6 +997,8 @@ func (a apexPackaging) name() string { } } +// apexFlattenedMutator creates one or more variations each of which is for a packaging method. +// TODO(jiyong): give a better name to this mutator func apexFlattenedMutator(mctx android.BottomUpMutatorContext) { if !mctx.Module().Enabled() { return @@ -914,13 +1007,21 @@ func apexFlattenedMutator(mctx android.BottomUpMutatorContext) { var variants []string switch proptools.StringDefault(ab.properties.Payload_type, "image") { case "image": + // This is the normal case. Note that both image and flattend APEXes are + // created. The image type is installed to the system partition, while the + // flattened APEX is (optionally) installed to the system_ext partition. + // This is mostly for GSI which has to support wide range of devices. If GSI + // is installed on a newer (APEX-capable) device, the image APEX in the + // system will be used. However, if the same GSI is installed on an old + // device which can't support image APEX, the flattened APEX in the + // system_ext partion (which still is part of GSI) is used instead. variants = append(variants, imageApexType, flattenedApexType) case "zip": variants = append(variants, zipApexType) case "both": variants = append(variants, imageApexType, zipApexType, flattenedApexType) default: - mctx.PropertyErrorf("type", "%q is not one of \"image\", \"zip\", or \"both\".", *ab.properties.Payload_type) + mctx.PropertyErrorf("payload_type", "%q is not one of \"image\", \"zip\", or \"both\".", *ab.properties.Payload_type) return } @@ -934,26 +1035,35 @@ func apexFlattenedMutator(mctx android.BottomUpMutatorContext) { modules[i].(*apexBundle).properties.ApexType = zipApex case flattenedApexType: modules[i].(*apexBundle).properties.ApexType = flattenedApex + // See the comment above for why system_ext. if !mctx.Config().FlattenApex() && ab.Platform() { modules[i].(*apexBundle).MakeAsSystemExt() } } } } else if _, ok := mctx.Module().(*OverrideApex); ok { + // payload_type is forcibly overridden to "image" + // TODO(jiyong): is this the right decision? mctx.CreateVariations(imageApexType, flattenedApexType) } } +// checkUseVendorProperty checks if the use of `use_vendor` property is allowed for the given APEX. +// When use_vendor is used, native modules are built with __ANDROID_VNDK__ and __ANDROID_APEX__, +// which may cause compatibility issues. (e.g. libbinder) Even though libbinder restricts its +// availability via 'apex_available' property and relies on yet another macro +// __ANDROID_APEX___, we restrict usage of "use_vendor:" from other APEX modules to avoid +// similar problems. +func checkUseVendorProperty(ctx android.BottomUpMutatorContext, a *apexBundle) { + if proptools.Bool(a.properties.Use_vendor) && !android.InList(a.Name(), useVendorAllowList(ctx.Config())) { + ctx.PropertyErrorf("use_vendor", "not allowed to set use_vendor: true") + } +} + var ( useVendorAllowListKey = android.NewOnceKey("useVendorAllowList") ) -// useVendorAllowList returns the list of APEXes which are allowed to use_vendor. -// When use_vendor is used, native modules are built with __ANDROID_VNDK__ and __ANDROID_APEX__, -// which may cause compatibility issues. (e.g. libbinder) -// Even though libbinder restricts its availability via 'apex_available' property and relies on -// yet another macro __ANDROID_APEX___, we restrict usage of "use_vendor:" from other APEX modules -// to avoid similar problems. func useVendorAllowList(config android.Config) []string { return config.Once(useVendorAllowListKey, func() interface{} { return []string{ @@ -964,41 +1074,74 @@ func useVendorAllowList(config android.Config) []string { }).([]string) } -// setUseVendorAllowListForTest overrides useVendorAllowList and must be -// called before the first call to useVendorAllowList() +// setUseVendorAllowListForTest overrides useVendorAllowList and must be called before the first +// call to useVendorAllowList() func setUseVendorAllowListForTest(config android.Config, allowList []string) { config.Once(useVendorAllowListKey, func() interface{} { return allowList }) } -type fsType int - -const ( - ext4 fsType = iota - f2fs -) - -func (f fsType) string() string { - switch f { - case ext4: - return ext4FsType - case f2fs: - return f2fsFsType - default: - panic(fmt.Errorf("unknown APEX payload type %d", f)) - } -} +var _ android.DepIsInSameApex = (*apexBundle)(nil) +// Implements android.DepInInSameApex func (a *apexBundle) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool { // direct deps of an APEX bundle are all part of the APEX bundle + // TODO(jiyong): shouldn't we look into the payload field of the dependencyTag? return true } +var _ android.OutputFileProducer = (*apexBundle)(nil) + +// Implements android.OutputFileProducer +func (a *apexBundle) OutputFiles(tag string) (android.Paths, error) { + switch tag { + case "": + return android.Paths{a.outputFile}, nil + default: + return nil, fmt.Errorf("unsupported module reference tag %q", tag) + } +} + +var _ cc.Coverage = (*apexBundle)(nil) + +// Implements cc.Coverage +func (a *apexBundle) IsNativeCoverageNeeded(ctx android.BaseModuleContext) bool { + return ctx.Device() && ctx.DeviceConfig().NativeCoverageEnabled() +} + +// Implements cc.Coverage +func (a *apexBundle) PreventInstall() { + a.properties.PreventInstall = true +} + +// Implements cc.Coverage +func (a *apexBundle) HideFromMake() { + a.properties.HideFromMake = true +} + +// Implements cc.Coverage +func (a *apexBundle) MarkAsCoverageVariant(coverage bool) { + a.properties.IsCoverageVariant = coverage +} + +// Implements cc.Coverage +func (a *apexBundle) EnableCoverageIfNeeded() {} + +var _ android.ApexBundleDepsInfoIntf = (*apexBundle)(nil) + +// Implements android.ApexBudleDepsInfoIntf +func (a *apexBundle) Updatable() bool { + return proptools.Bool(a.properties.Updatable) +} + +// getCertString returns the name of the cert that should be used to sign this APEX. This is +// basically from the "certificate" property, but could be overridden by the device config. func (a *apexBundle) getCertString(ctx android.BaseModuleContext) string { moduleName := ctx.ModuleName() - // VNDK APEXes share the same certificate. To avoid adding a new VNDK version to the OVERRIDE_* list, - // we check with the pseudo module name to see if its certificate is overridden. + // VNDK APEXes share the same certificate. To avoid adding a new VNDK version to the + // OVERRIDE_* list, we check with the pseudo module name to see if its certificate is + // overridden. if a.vndkApex { moduleName = vndkApexName } @@ -1009,55 +1152,24 @@ func (a *apexBundle) getCertString(ctx android.BaseModuleContext) string { return String(a.properties.Certificate) } -func (a *apexBundle) OutputFiles(tag string) (android.Paths, error) { - switch tag { - case "": - return android.Paths{a.outputFile}, nil - default: - return nil, fmt.Errorf("unsupported module reference tag %q", tag) - } -} - +// See the installable property func (a *apexBundle) installable() bool { return !a.properties.PreventInstall && (a.properties.Installable == nil || proptools.Bool(a.properties.Installable)) } +// See the test_only_no_hashtree property func (a *apexBundle) testOnlyShouldSkipHashtreeGeneration() bool { return proptools.Bool(a.properties.Test_only_no_hashtree) } +// See the test_only_unsigned_payload property func (a *apexBundle) testOnlyShouldSkipPayloadSign() bool { return proptools.Bool(a.properties.Test_only_unsigned_payload) } -func (a *apexBundle) getImageVariation(ctx android.BottomUpMutatorContext) string { - deviceConfig := ctx.DeviceConfig() - if a.vndkApex { - return cc.VendorVariationPrefix + a.vndkVersion(deviceConfig) - } - - var prefix string - var vndkVersion string - if deviceConfig.VndkVersion() != "" { - if proptools.Bool(a.properties.Use_vendor) { - prefix = cc.VendorVariationPrefix - vndkVersion = deviceConfig.PlatformVndkVersion() - } else if a.SocSpecific() || a.DeviceSpecific() { - prefix = cc.VendorVariationPrefix - vndkVersion = deviceConfig.VndkVersion() - } else if a.ProductSpecific() { - prefix = cc.ProductVariationPrefix - vndkVersion = deviceConfig.ProductVndkVersion() - } - } - if vndkVersion == "current" { - vndkVersion = deviceConfig.PlatformVndkVersion() - } - if vndkVersion != "" { - return prefix + vndkVersion - } - return android.CoreVariation -} +// These functions are interfacing with cc/sanitizer.go. The entire APEX (along with all of its +// members) can be sanitized, either forcibly, or by the global configuration. For some of the +// sanitizers, extra dependencies can be forcibly added as well. func (a *apexBundle) EnableSanitizer(sanitizerName string) { if !android.InList(sanitizerName, a.properties.SanitizerNames) { @@ -1084,44 +1196,31 @@ func (a *apexBundle) IsSanitizerEnabled(ctx android.BaseModuleContext, sanitizer } func (a *apexBundle) AddSanitizerDependencies(ctx android.BottomUpMutatorContext, sanitizerName string) { + // TODO(jiyong): move this info (the sanitizer name, the lib name, etc.) to cc/sanitize.go + // Keep only the mechanism here. if ctx.Device() && sanitizerName == "hwaddress" && strings.HasPrefix(a.Name(), "com.android.runtime") { + imageVariation := a.getImageVariation(ctx) for _, target := range ctx.MultiTargets() { if target.Arch.ArchType.Multilib == "lib64" { - ctx.AddFarVariationDependencies(append(target.Variations(), []blueprint.Variation{ - {Mutator: "image", Variation: a.getImageVariation(ctx)}, - {Mutator: "link", Variation: "shared"}, - {Mutator: "version", Variation: ""}, // "" is the non-stub variant - }...), sharedLibTag, "libclang_rt.hwasan-aarch64-android") + addDependenciesForNativeModules(ctx, ApexNativeDependencies{ + Native_shared_libs: []string{"libclang_rt.hwasan-aarch64-android"}, + Tests: nil, + Jni_libs: nil, + Binaries: nil, + }, target, imageVariation) break } } } } -var _ cc.Coverage = (*apexBundle)(nil) - -func (a *apexBundle) IsNativeCoverageNeeded(ctx android.BaseModuleContext) bool { - return ctx.Device() && ctx.DeviceConfig().NativeCoverageEnabled() -} - -func (a *apexBundle) PreventInstall() { - a.properties.PreventInstall = true -} - -func (a *apexBundle) HideFromMake() { - a.properties.HideFromMake = true -} - -func (a *apexBundle) MarkAsCoverageVariant(coverage bool) { - a.properties.IsCoverageVariant = coverage -} - -func (a *apexBundle) EnableCoverageIfNeeded() {} - -// TODO(jiyong) move apexFileFor* close to the apexFile type definition +// apexFileFor functions below create an apexFile struct for a given Soong module. The +// returned apexFile saves information about the Soong module that will be used for creating the +// build rules. func apexFileForNativeLibrary(ctx android.BaseModuleContext, ccMod *cc.Module, handleSpecialLibs bool) apexFile { - // Decide the APEX-local directory by the multilib of the library - // In the future, we may query this to the module. + // Decide the APEX-local directory by the multilib of the library In the future, we may + // query this to the module. + // TODO(jiyong): use the new PackagingSpec var dirInApex string switch ccMod.Arch().ArchType.Multilib { case "lib32": @@ -1134,16 +1233,15 @@ func apexFileForNativeLibrary(ctx android.BaseModuleContext, ccMod *cc.Module, h } dirInApex = filepath.Join(dirInApex, ccMod.RelativeInstallPath()) if handleSpecialLibs && cc.InstallToBootstrap(ccMod.BaseModuleName(), ctx.Config()) { - // Special case for Bionic libs and other libs installed with them. This is - // to prevent those libs from being included in the search path - // /apex/com.android.runtime/${LIB}. This exclusion is required because - // those libs in the Runtime APEX are available via the legacy paths in - // /system/lib/. By the init process, the libs in the APEX are bind-mounted - // to the legacy paths and thus will be loaded into the default linker - // namespace (aka "platform" namespace). If the libs are directly in - // /apex/com.android.runtime/${LIB} then the same libs will be loaded again - // into the runtime linker namespace, which will result in double loading of - // them, which isn't supported. + // Special case for Bionic libs and other libs installed with them. This is to + // prevent those libs from being included in the search path + // /apex/com.android.runtime/${LIB}. This exclusion is required because those libs + // in the Runtime APEX are available via the legacy paths in /system/lib/. By the + // init process, the libs in the APEX are bind-mounted to the legacy paths and thus + // will be loaded into the default linker namespace (aka "platform" namespace). If + // the libs are directly in /apex/com.android.runtime/${LIB} then the same libs will + // be loaded again into the runtime linker namespace, which will result in double + // loading of them, which isn't supported. dirInApex = filepath.Join(dirInApex, "bionic") } @@ -1171,6 +1269,7 @@ func apexFileForPyBinary(ctx android.BaseModuleContext, py *python.Module) apexF fileToCopy := py.HostToolPath().Path() return newApexFile(ctx, fileToCopy, py.BaseModuleName(), dirInApex, pyBinary, py) } + func apexFileForGoBinary(ctx android.BaseModuleContext, depName string, gb bootstrap.GoBinaryTool) apexFile { dirInApex := "bin" s, err := filepath.Rel(android.PathForOutput(ctx).String(), gb.InstallPath()) @@ -1193,31 +1292,6 @@ func apexFileForShBinary(ctx android.BaseModuleContext, sh *sh.ShBinary) apexFil return af } -type javaModule interface { - android.Module - BaseModuleName() string - DexJarBuildPath() android.Path - JacocoReportClassesFile() android.Path - LintDepSets() java.LintDepSets - - Stem() string -} - -var _ javaModule = (*java.Library)(nil) -var _ javaModule = (*java.SdkLibrary)(nil) -var _ javaModule = (*java.DexImport)(nil) -var _ javaModule = (*java.SdkLibraryImport)(nil) - -func apexFileForJavaLibrary(ctx android.BaseModuleContext, module javaModule) apexFile { - dirInApex := "javalib" - fileToCopy := module.DexJarBuildPath() - af := newApexFile(ctx, fileToCopy, module.BaseModuleName(), dirInApex, javaSharedLib, module) - af.jacocoReportClassesFile = module.JacocoReportClassesFile() - af.lintDepSets = module.LintDepSets() - af.stem = module.Stem() + ".jar" - return af -} - func apexFileForPrebuiltEtc(ctx android.BaseModuleContext, prebuilt prebuilt_etc.PrebuiltEtcModule, depName string) apexFile { dirInApex := filepath.Join(prebuilt.BaseDir(), prebuilt.SubDir()) fileToCopy := prebuilt.OutputFile() @@ -1230,7 +1304,35 @@ func apexFileForCompatConfig(ctx android.BaseModuleContext, config java.Platform return newApexFile(ctx, fileToCopy, depName, dirInApex, etc, config) } -func apexFileForAndroidApp(ctx android.BaseModuleContext, aapp interface { +// javaModule is an interface to handle all Java modules (java_library, dex_import, etc) in the same +// way. +type javaModule interface { + android.Module + BaseModuleName() string + DexJarBuildPath() android.Path + JacocoReportClassesFile() android.Path + LintDepSets() java.LintDepSets + Stem() string +} + +var _ javaModule = (*java.Library)(nil) +var _ javaModule = (*java.SdkLibrary)(nil) +var _ javaModule = (*java.DexImport)(nil) +var _ javaModule = (*java.SdkLibraryImport)(nil) + +func apexFileForJavaModule(ctx android.BaseModuleContext, module javaModule) apexFile { + dirInApex := "javalib" + fileToCopy := module.DexJarBuildPath() + af := newApexFile(ctx, fileToCopy, module.BaseModuleName(), dirInApex, javaSharedLib, module) + af.jacocoReportClassesFile = module.JacocoReportClassesFile() + af.lintDepSets = module.LintDepSets() + af.customStem = module.Stem() + ".jar" + return af +} + +// androidApp is an interface to handle all app modules (android_app, android_app_import, etc.) in +// the same way. +type androidApp interface { android.Module Privileged() bool InstallApkName() string @@ -1238,7 +1340,12 @@ func apexFileForAndroidApp(ctx android.BaseModuleContext, aapp interface { JacocoReportClassesFile() android.Path Certificate() java.Certificate BaseModuleName() string -}) apexFile { +} + +var _ androidApp = (*java.AndroidApp)(nil) +var _ androidApp = (*java.AndroidAppImport)(nil) + +func apexFileForAndroidApp(ctx android.BaseModuleContext, aapp androidApp) apexFile { appDir := "app" if aapp.Privileged() { appDir = "priv-app" @@ -1277,16 +1384,10 @@ func apexFileForBpfProgram(ctx android.BaseModuleContext, builtFile android.Path return newApexFile(ctx, builtFile, builtFile.Base(), dirInApex, etc, bpfProgram) } -// Context "decorator", overriding the InstallBypassMake method to always reply `true`. -type flattenedApexContext struct { - android.ModuleContext -} - -func (c *flattenedApexContext) InstallBypassMake() bool { - return true -} - -// Visit dependencies that contributes to the payload of this APEX +// WalyPayloadDeps visits dependencies that contributes to the payload of this APEX. For each of the +// visited module, the `do` callback is executed. Returning true in the callback continues the visit +// to the child modules. Returning false makes the visit to continue in the sibling or the parent +// modules. This is used in check* functions below. func (a *apexBundle) WalkPayloadDeps(ctx android.ModuleContext, do android.PayloadDepsCallback) { ctx.WalkDeps(func(child, parent android.Module) bool { am, ok := child.(android.ApexModule) @@ -1294,213 +1395,74 @@ func (a *apexBundle) WalkPayloadDeps(ctx android.ModuleContext, do android.Paylo return false } - childApexInfo := ctx.OtherModuleProvider(child, android.ApexInfoProvider).(android.ApexInfo) - - dt := ctx.OtherModuleDependencyTag(child) - - if _, ok := dt.(android.ExcludeFromApexContentsTag); ok { + // Filter-out unwanted depedendencies + depTag := ctx.OtherModuleDependencyTag(child) + if _, ok := depTag.(android.ExcludeFromApexContentsTag); ok { + return false + } + if dt, ok := depTag.(dependencyTag); ok && !dt.payload { return false } - // Check for the direct dependencies that contribute to the payload - if adt, ok := dt.(dependencyTag); ok { - if adt.payload { - return do(ctx, parent, am, false /* externalDep */) - } - // As soon as the dependency graph crosses the APEX boundary, don't go further. - return false - } + ai := ctx.OtherModuleProvider(child, android.ApexInfoProvider).(android.ApexInfo) + externalDep := !android.InList(ctx.ModuleName(), ai.InApexes) - // Check for the indirect dependencies if it is considered as part of the APEX - if android.InList(ctx.ModuleName(), childApexInfo.InApexes) { - return do(ctx, parent, am, false /* externalDep */) - } - - return do(ctx, parent, am, true /* externalDep */) + // Visit actually + return do(ctx, parent, am, externalDep) }) } -func (a *apexBundle) minSdkVersion(ctx android.BaseModuleContext) android.ApiLevel { - ver := proptools.String(a.properties.Min_sdk_version) - if ver == "" { - return android.FutureApiLevel - } - apiLevel, err := android.ApiLevelFromUser(ctx, ver) - if err != nil { - ctx.PropertyErrorf("min_sdk_version", "%s", err.Error()) - return android.NoneApiLevel - } - if apiLevel.IsPreview() { - // All codenames should build against "current". - return android.FutureApiLevel - } - return apiLevel -} +// filesystem type of the apex_payload.img inside the APEX. Currently, ext4 and f2fs are supported. +type fsType int -func (a *apexBundle) Updatable() bool { - return proptools.Bool(a.properties.Updatable) -} +const ( + ext4 fsType = iota + f2fs +) -var _ android.ApexBundleDepsInfoIntf = (*apexBundle)(nil) - -// Ensures that the dependencies are marked as available for this APEX -func (a *apexBundle) checkApexAvailability(ctx android.ModuleContext) { - // Let's be practical. Availability for test, host, and the VNDK apex isn't important - if ctx.Host() || a.testApex || a.vndkApex { - return - } - - // Because APEXes targeting other than system/system_ext partitions - // can't set apex_available, we skip checks for these APEXes - if a.SocSpecific() || a.DeviceSpecific() || - (a.ProductSpecific() && ctx.Config().EnforceProductPartitionInterface()) { - return - } - - // Coverage build adds additional dependencies for the coverage-only runtime libraries. - // Requiring them and their transitive depencies with apex_available is not right - // because they just add noise. - if ctx.Config().IsEnvTrue("EMMA_INSTRUMENT") || a.IsNativeCoverageNeeded(ctx) { - return - } - - a.WalkPayloadDeps(ctx, func(ctx android.ModuleContext, from blueprint.Module, to android.ApexModule, externalDep bool) bool { - if externalDep { - // As soon as the dependency graph crosses the APEX boundary, don't go further. - return false - } - - apexName := ctx.ModuleName() - fromName := ctx.OtherModuleName(from) - toName := ctx.OtherModuleName(to) - - // If `to` is not actually in the same APEX as `from` then it does not need apex_available and neither - // do any of its dependencies. - if am, ok := from.(android.DepIsInSameApex); ok && !am.DepIsInSameApex(ctx, to) { - // As soon as the dependency graph crosses the APEX boundary, don't go further. - return false - } - - if to.AvailableFor(apexName) || baselineApexAvailable(apexName, toName) { - return true - } - ctx.ModuleErrorf("%q requires %q that doesn't list the APEX under 'apex_available'. Dependency path:%s", fromName, toName, ctx.GetPathString(true)) - // Visit this module's dependencies to check and report any issues with their availability. - return true - }) -} - -func (a *apexBundle) checkUpdatable(ctx android.ModuleContext) { - if a.Updatable() { - if String(a.properties.Min_sdk_version) == "" { - ctx.PropertyErrorf("updatable", "updatable APEXes should set min_sdk_version as well") - } - - a.checkJavaStableSdkVersion(ctx) +func (f fsType) string() string { + switch f { + case ext4: + return ext4FsType + case f2fs: + return f2fsFsType + default: + panic(fmt.Errorf("unknown APEX payload type %d", f)) } } -func (a *apexBundle) checkMinSdkVersion(ctx android.ModuleContext) { - if a.testApex || a.vndkApex { - return - } - // Meaningless to check min_sdk_version when building use_vendor modules against non-Trebleized targets - if proptools.Bool(a.properties.Use_vendor) && ctx.DeviceConfig().VndkVersion() == "" { - return - } - // apexBundle::minSdkVersion reports its own errors. - minSdkVersion := a.minSdkVersion(ctx) - android.CheckMinSdkVersion(a, ctx, minSdkVersion) -} - -// Ensures that a lib providing stub isn't statically linked -func (a *apexBundle) checkStaticLinkingToStubLibraries(ctx android.ModuleContext) { - // Practically, we only care about regular APEXes on the device. - if ctx.Host() || a.testApex || a.vndkApex { - return - } - - abInfo := ctx.Provider(ApexBundleInfoProvider).(ApexBundleInfo) - - a.WalkPayloadDeps(ctx, func(ctx android.ModuleContext, from blueprint.Module, to android.ApexModule, externalDep bool) bool { - if ccm, ok := to.(*cc.Module); ok { - apexName := ctx.ModuleName() - fromName := ctx.OtherModuleName(from) - toName := ctx.OtherModuleName(to) - - // If `to` is not actually in the same APEX as `from` then it does not need apex_available and neither - // do any of its dependencies. - if am, ok := from.(android.DepIsInSameApex); ok && !am.DepIsInSameApex(ctx, to) { - // As soon as the dependency graph crosses the APEX boundary, don't go further. - return false - } - - // The dynamic linker and crash_dump tool in the runtime APEX is the only exception to this rule. - // It can't make the static dependencies dynamic because it can't - // do the dynamic linking for itself. - if apexName == "com.android.runtime" && (fromName == "linker" || fromName == "crash_dump") { - return false - } - - isStubLibraryFromOtherApex := ccm.HasStubsVariants() && !abInfo.Contents.DirectlyInApex(toName) - if isStubLibraryFromOtherApex && !externalDep { - ctx.ModuleErrorf("%q required by %q is a native library providing stub. "+ - "It shouldn't be included in this APEX via static linking. Dependency path: %s", to.String(), fromName, ctx.GetPathString(false)) - } - - } - return true - }) -} - +// Creates build rules for an APEX. It consists of the following major steps: +// +// 1) do some validity checks such as apex_available, min_sdk_version, etc. +// 2) traverse the dependency tree to collect apexFile structs from them. +// 3) some fields in apexBundle struct are configured +// 4) generate the build rules to create the APEX. This is mostly done in builder.go. func (a *apexBundle) GenerateAndroidBuildActions(ctx android.ModuleContext) { - buildFlattenedAsDefault := ctx.Config().FlattenApex() && !ctx.Config().UnbundledBuildApps() - switch a.properties.ApexType { - case imageApex: - if buildFlattenedAsDefault { - a.suffix = imageApexSuffix - } else { - a.suffix = "" - a.primaryApexType = true - - if ctx.Config().InstallExtraFlattenedApexes() { - a.requiredDeps = append(a.requiredDeps, a.Name()+flattenedSuffix) - } - } - case zipApex: - if proptools.String(a.properties.Payload_type) == "zip" { - a.suffix = "" - a.primaryApexType = true - } else { - a.suffix = zipApexSuffix - } - case flattenedApex: - if buildFlattenedAsDefault { - a.suffix = "" - a.primaryApexType = true - } else { - a.suffix = flattenedSuffix - } - } - - if len(a.properties.Tests) > 0 && !a.testApex { - ctx.PropertyErrorf("tests", "property not allowed in apex module type") - return - } - + //////////////////////////////////////////////////////////////////////////////////////////// + // 1) do some validity checks such as apex_available, min_sdk_version, etc. a.checkApexAvailability(ctx) a.checkUpdatable(ctx) a.checkMinSdkVersion(ctx) a.checkStaticLinkingToStubLibraries(ctx) + if len(a.properties.Tests) > 0 && !a.testApex { + ctx.PropertyErrorf("tests", "property allowed only in apex_test module type") + return + } - handleSpecialLibs := !android.Bool(a.properties.Ignore_system_library_special_case) + //////////////////////////////////////////////////////////////////////////////////////////// + // 2) traverse the dependency tree to collect apexFile structs from them. + + // all the files that will be included in this APEX + var filesInfo []apexFile // native lib dependencies var provideNativeLibs []string var requireNativeLibs []string - var filesInfo []apexFile - // TODO(jiyong) do this using WalkPayloadDeps + handleSpecialLibs := !android.Bool(a.properties.Ignore_system_library_special_case) + + // TODO(jiyong): do this using WalkPayloadDeps + // TODO(jiyong): make this clean!!! ctx.WalkDepsBlueprint(func(child, parent blueprint.Module) bool { depTag := ctx.OtherModuleDependencyTag(child) if _, ok := depTag.(android.ExcludeFromApexContentsTag); ok { @@ -1519,7 +1481,7 @@ func (a *apexBundle) GenerateAndroidBuildActions(ctx android.ModuleContext) { // - VNDK libs are only for vendors // - bootstrap bionic libs are treated as provided by system if c.HasStubsVariants() && !a.vndkApex && !cc.InstallToBootstrap(c.BaseModuleName(), ctx.Config()) { - provideNativeLibs = append(provideNativeLibs, fi.Stem()) + provideNativeLibs = append(provideNativeLibs, fi.stem()) } return true // track transitive dependencies } else { @@ -1545,8 +1507,8 @@ func (a *apexBundle) GenerateAndroidBuildActions(ctx android.ModuleContext) { case javaLibTag: switch child.(type) { case *java.Library, *java.SdkLibrary, *java.DexImport, *java.SdkLibraryImport: - af := apexFileForJavaLibrary(ctx, child.(javaModule)) - if !af.Ok() { + af := apexFileForJavaModule(ctx, child.(javaModule)) + if !af.ok() { ctx.PropertyErrorf("java_libs", "%q is not configured to be compiled into dex", depName) return false } @@ -1674,7 +1636,7 @@ func (a *apexBundle) GenerateAndroidBuildActions(ctx android.ModuleContext) { a.requiredDeps = append(a.requiredDeps, name) } } - requireNativeLibs = append(requireNativeLibs, af.Stem()) + requireNativeLibs = append(requireNativeLibs, af.stem()) // Don't track further return false } @@ -1710,10 +1672,14 @@ func (a *apexBundle) GenerateAndroidBuildActions(ctx android.ModuleContext) { } return false }) + if a.private_key_file == nil { + ctx.PropertyErrorf("key", "private_key for %q could not be found", String(a.properties.Key)) + return + } - // Specific to the ART apex: dexpreopt artifacts for libcore Java libraries. - // Build rules are generated by the dexpreopt singleton, and here we access build artifacts - // via the global boot image config. + // Specific to the ART apex: dexpreopt artifacts for libcore Java libraries. Build rules are + // generated by the dexpreopt singleton, and here we access build artifacts via the global + // boot image config. if a.artApex { for arch, files := range java.DexpreoptedArtApexJars(ctx) { dirInApex := filepath.Join("javalib", arch.String()) @@ -1725,12 +1691,7 @@ func (a *apexBundle) GenerateAndroidBuildActions(ctx android.ModuleContext) { } } - if a.private_key_file == nil { - ctx.PropertyErrorf("key", "private_key for %q could not be found", String(a.properties.Key)) - return - } - - // remove duplicates in filesInfo + // Remove duplicates in filesInfo removeDup := func(filesInfo []apexFile) []apexFile { encountered := make(map[string]apexFile) for _, f := range filesInfo { @@ -1752,14 +1713,46 @@ func (a *apexBundle) GenerateAndroidBuildActions(ctx android.ModuleContext) { } filesInfo = removeDup(filesInfo) - // to have consistent build rules + // Sort to have consistent build rules sort.Slice(filesInfo, func(i, j int) bool { return filesInfo[i].builtFile.String() < filesInfo[j].builtFile.String() }) + //////////////////////////////////////////////////////////////////////////////////////////// + // 3) some fields in apexBundle struct are configured a.installDir = android.PathForModuleInstall(ctx, "apex") a.filesInfo = filesInfo + // Set suffix and primaryApexType depending on the ApexType + buildFlattenedAsDefault := ctx.Config().FlattenApex() && !ctx.Config().UnbundledBuildApps() + switch a.properties.ApexType { + case imageApex: + if buildFlattenedAsDefault { + a.suffix = imageApexSuffix + } else { + a.suffix = "" + a.primaryApexType = true + + if ctx.Config().InstallExtraFlattenedApexes() { + a.requiredDeps = append(a.requiredDeps, a.Name()+flattenedSuffix) + } + } + case zipApex: + if proptools.String(a.properties.Payload_type) == "zip" { + a.suffix = "" + a.primaryApexType = true + } else { + a.suffix = zipApexSuffix + } + case flattenedApex: + if buildFlattenedAsDefault { + a.suffix = "" + a.primaryApexType = true + } else { + a.suffix = flattenedSuffix + } + } + switch proptools.StringDefault(a.properties.Payload_fs_type, ext4FsType) { case ext4FsType: a.payloadFsType = ext4 @@ -1774,14 +1767,11 @@ func (a *apexBundle) GenerateAndroidBuildActions(ctx android.ModuleContext) { // the same library in the system partition, thus effectively sharing the same libraries // across the APEX boundary. For unbundled APEX, all the gathered files are actually placed // in the APEX. - a.linkToSystemLib = !ctx.Config().UnbundledBuild() && - a.installable() && - !proptools.Bool(a.properties.Use_vendor) + a.linkToSystemLib = !ctx.Config().UnbundledBuild() && a.installable() && !proptools.Bool(a.properties.Use_vendor) // APEXes targeting other than system/system_ext partitions use vendor/product variants. // So we can't link them to /system/lib libs which are core variants. - if a.SocSpecific() || a.DeviceSpecific() || - (a.ProductSpecific() && ctx.Config().EnforceProductPartitionInterface()) { + if a.SocSpecific() || a.DeviceSpecific() || (a.ProductSpecific() && ctx.Config().EnforceProductPartitionInterface()) { a.linkToSystemLib = false } @@ -1796,31 +1786,201 @@ func (a *apexBundle) GenerateAndroidBuildActions(ctx android.ModuleContext) { a.linkToSystemLib = false } - // prepare apex_manifest.json - a.buildManifest(ctx, provideNativeLibs, requireNativeLibs) - - a.buildFileContexts(ctx) - a.setCertificateAndPrivateKey(ctx) + + a.compatSymlinks = makeCompatSymlinks(a.BaseModuleName(), ctx) + + //////////////////////////////////////////////////////////////////////////////////////////// + // 4) generate the build rules to create the APEX. This is done in builder.go. + a.buildManifest(ctx, provideNativeLibs, requireNativeLibs) + a.buildFileContexts(ctx) if a.properties.ApexType == flattenedApex { a.buildFlattenedApex(ctx) } else { a.buildUnflattenedApex(ctx) } - - a.compatSymlinks = makeCompatSymlinks(a.BaseModuleName(), ctx) - a.buildApexDependencyInfo(ctx) - a.buildLintReports(ctx) - a.distFiles = a.GenerateTaggedDistFiles(ctx) } +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Factory functions +// + +func newApexBundle() *apexBundle { + module := &apexBundle{} + + module.AddProperties(&module.properties) + module.AddProperties(&module.targetProperties) + module.AddProperties(&module.overridableProperties) + + android.InitAndroidMultiTargetsArchModule(module, android.HostAndDeviceSupported, android.MultilibCommon) + android.InitDefaultableModule(module) + android.InitSdkAwareModule(module) + android.InitOverridableModule(module, &module.overridableProperties.Overrides) + return module +} + +func ApexBundleFactory(testApex bool, artApex bool) android.Module { + bundle := newApexBundle() + bundle.testApex = testApex + bundle.artApex = artApex + return bundle +} + +// apex_test is an APEX for testing. The difference from the ordinary apex module type is that +// certain compatibility checks such as apex_available are not done for apex_test. +func testApexBundleFactory() android.Module { + bundle := newApexBundle() + bundle.testApex = true + return bundle +} + +// apex packages other modules into an APEX file which is a packaging format for system-level +// components like binaries, shared libraries, etc. +func BundleFactory() android.Module { + return newApexBundle() +} + +type Defaults struct { + android.ModuleBase + android.DefaultsModuleBase +} + +// apex_defaults provides defaultable properties to other apex modules. +func defaultsFactory() android.Module { + return DefaultsFactory() +} + +func DefaultsFactory(props ...interface{}) android.Module { + module := &Defaults{} + + module.AddProperties(props...) + module.AddProperties( + &apexBundleProperties{}, + &apexTargetBundleProperties{}, + &overridableProperties{}, + ) + + android.InitDefaultsModule(module) + return module +} + +type OverrideApex struct { + android.ModuleBase + android.OverrideModuleBase +} + +func (o *OverrideApex) GenerateAndroidBuildActions(ctx android.ModuleContext) { + // All the overrides happen in the base module. +} + +// override_apex is used to create an apex module based on another apex module by overriding some of +// its properties. +func overrideApexFactory() android.Module { + m := &OverrideApex{} + + m.AddProperties(&overridableProperties{}) + + android.InitAndroidMultiTargetsArchModule(m, android.DeviceSupported, android.MultilibCommon) + android.InitOverrideModule(m) + return m +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Vality check routines +// +// These are called in at the very beginning of GenerateAndroidBuildActions to flag an error when +// certain conditions are not met. +// +// TODO(jiyong): move these checks to a separate go file. + +// Entures that min_sdk_version of the included modules are equal or less than the min_sdk_version +// of this apexBundle. +func (a *apexBundle) checkMinSdkVersion(ctx android.ModuleContext) { + if a.testApex || a.vndkApex { + return + } + // Meaningless to check min_sdk_version when building use_vendor modules against non-Trebleized targets + if proptools.Bool(a.properties.Use_vendor) && ctx.DeviceConfig().VndkVersion() == "" { + return + } + // apexBundle::minSdkVersion reports its own errors. + minSdkVersion := a.minSdkVersion(ctx) + android.CheckMinSdkVersion(a, ctx, minSdkVersion) +} + +func (a *apexBundle) minSdkVersion(ctx android.BaseModuleContext) android.ApiLevel { + ver := proptools.String(a.properties.Min_sdk_version) + if ver == "" { + return android.FutureApiLevel + } + apiLevel, err := android.ApiLevelFromUser(ctx, ver) + if err != nil { + ctx.PropertyErrorf("min_sdk_version", "%s", err.Error()) + return android.NoneApiLevel + } + if apiLevel.IsPreview() { + // All codenames should build against "current". + return android.FutureApiLevel + } + return apiLevel +} + +// Ensures that a lib providing stub isn't statically linked +func (a *apexBundle) checkStaticLinkingToStubLibraries(ctx android.ModuleContext) { + // Practically, we only care about regular APEXes on the device. + if ctx.Host() || a.testApex || a.vndkApex { + return + } + + abInfo := ctx.Provider(ApexBundleInfoProvider).(ApexBundleInfo) + + a.WalkPayloadDeps(ctx, func(ctx android.ModuleContext, from blueprint.Module, to android.ApexModule, externalDep bool) bool { + if ccm, ok := to.(*cc.Module); ok { + apexName := ctx.ModuleName() + fromName := ctx.OtherModuleName(from) + toName := ctx.OtherModuleName(to) + + // If `to` is not actually in the same APEX as `from` then it does not need + // apex_available and neither do any of its dependencies. + if am, ok := from.(android.DepIsInSameApex); ok && !am.DepIsInSameApex(ctx, to) { + // As soon as the dependency graph crosses the APEX boundary, don't go further. + return false + } + + // The dynamic linker and crash_dump tool in the runtime APEX is the only + // exception to this rule. It can't make the static dependencies dynamic + // because it can't do the dynamic linking for itself. + if apexName == "com.android.runtime" && (fromName == "linker" || fromName == "crash_dump") { + return false + } + + isStubLibraryFromOtherApex := ccm.HasStubsVariants() && !abInfo.Contents.DirectlyInApex(toName) + if isStubLibraryFromOtherApex && !externalDep { + ctx.ModuleErrorf("%q required by %q is a native library providing stub. "+ + "It shouldn't be included in this APEX via static linking. Dependency path: %s", to.String(), fromName, ctx.GetPathString(false)) + } + + } + return true + }) +} + // Enforce that Java deps of the apex are using stable SDKs to compile +func (a *apexBundle) checkUpdatable(ctx android.ModuleContext) { + if a.Updatable() { + if String(a.properties.Min_sdk_version) == "" { + ctx.PropertyErrorf("updatable", "updatable APEXes should set min_sdk_version as well") + } + a.checkJavaStableSdkVersion(ctx) + } +} + func (a *apexBundle) checkJavaStableSdkVersion(ctx android.ModuleContext) { - // Visit direct deps only. As long as we guarantee top-level deps are using - // stable SDKs, java's checkLinkType guarantees correct usage for transitive deps + // Visit direct deps only. As long as we guarantee top-level deps are using stable SDKs, + // java's checkLinkType guarantees correct usage for transitive deps ctx.VisitDirectDepsBlueprint(func(module blueprint.Module) { tag := ctx.OtherModuleDependencyTag(module) switch tag { @@ -1834,6 +1994,59 @@ func (a *apexBundle) checkJavaStableSdkVersion(ctx android.ModuleContext) { }) } +// Ensures that the all the dependencies are marked as available for this APEX +func (a *apexBundle) checkApexAvailability(ctx android.ModuleContext) { + // Let's be practical. Availability for test, host, and the VNDK apex isn't important + if ctx.Host() || a.testApex || a.vndkApex { + return + } + + // Because APEXes targeting other than system/system_ext partitions can't set + // apex_available, we skip checks for these APEXes + if a.SocSpecific() || a.DeviceSpecific() || (a.ProductSpecific() && ctx.Config().EnforceProductPartitionInterface()) { + return + } + + // Coverage build adds additional dependencies for the coverage-only runtime libraries. + // Requiring them and their transitive depencies with apex_available is not right + // because they just add noise. + if ctx.Config().IsEnvTrue("EMMA_INSTRUMENT") || a.IsNativeCoverageNeeded(ctx) { + return + } + + a.WalkPayloadDeps(ctx, func(ctx android.ModuleContext, from blueprint.Module, to android.ApexModule, externalDep bool) bool { + // As soon as the dependency graph crosses the APEX boundary, don't go further. + if externalDep { + return false + } + + apexName := ctx.ModuleName() + fromName := ctx.OtherModuleName(from) + toName := ctx.OtherModuleName(to) + + // If `to` is not actually in the same APEX as `from` then it does not need + // apex_available and neither do any of its dependencies. + if am, ok := from.(android.DepIsInSameApex); ok && !am.DepIsInSameApex(ctx, to) { + // As soon as the dependency graph crosses the APEX boundary, don't go + // further. + return false + } + + if to.AvailableFor(apexName) || baselineApexAvailable(apexName, toName) { + return true + } + ctx.ModuleErrorf("%q requires %q that doesn't list the APEX under 'apex_available'. Dependency path:%s", + fromName, toName, ctx.GetPathString(true)) + // Visit this module's dependencies to check and report any issues with their availability. + return true + }) +} + +var ( + apexAvailBaseline = makeApexAvailableBaseline() + inverseApexAvailBaseline = invertApexBaseline(apexAvailBaseline) +) + func baselineApexAvailable(apex, moduleName string) bool { key := apex moduleName = normalizeModuleName(moduleName) @@ -1866,93 +2079,6 @@ func normalizeModuleName(moduleName string) string { return moduleName } -func newApexBundle() *apexBundle { - module := &apexBundle{} - module.AddProperties(&module.properties) - module.AddProperties(&module.targetProperties) - module.AddProperties(&module.overridableProperties) - android.InitAndroidMultiTargetsArchModule(module, android.HostAndDeviceSupported, android.MultilibCommon) - android.InitDefaultableModule(module) - android.InitSdkAwareModule(module) - android.InitOverridableModule(module, &module.overridableProperties.Overrides) - return module -} - -func ApexBundleFactory(testApex bool, artApex bool) android.Module { - bundle := newApexBundle() - bundle.testApex = testApex - bundle.artApex = artApex - return bundle -} - -// apex_test is an APEX for testing. The difference from the ordinary apex module type is that -// certain compatibility checks such as apex_available are not done for apex_test. -func testApexBundleFactory() android.Module { - bundle := newApexBundle() - bundle.testApex = true - return bundle -} - -// apex packages other modules into an APEX file which is a packaging format for system-level -// components like binaries, shared libraries, etc. -func BundleFactory() android.Module { - return newApexBundle() -} - -// -// Defaults -// -type Defaults struct { - android.ModuleBase - android.DefaultsModuleBase -} - -func defaultsFactory() android.Module { - return DefaultsFactory() -} - -func DefaultsFactory(props ...interface{}) android.Module { - module := &Defaults{} - - module.AddProperties(props...) - module.AddProperties( - &apexBundleProperties{}, - &apexTargetBundleProperties{}, - &overridableProperties{}, - ) - - android.InitDefaultsModule(module) - return module -} - -// -// OverrideApex -// -type OverrideApex struct { - android.ModuleBase - android.OverrideModuleBase -} - -func (o *OverrideApex) GenerateAndroidBuildActions(ctx android.ModuleContext) { - // All the overrides happen in the base module. -} - -// override_apex is used to create an apex module based on another apex module -// by overriding some of its properties. -func overrideApexFactory() android.Module { - m := &OverrideApex{} - m.AddProperties(&overridableProperties{}) - - android.InitAndroidMultiTargetsArchModule(m, android.DeviceSupported, android.MultilibCommon) - android.InitOverrideModule(m) - return m -} - -var ( - apexAvailBaseline = makeApexAvailableBaseline() - inverseApexAvailBaseline = invertApexBaseline(apexAvailBaseline) -) - // Transform the map of apex -> modules to module -> apexes. func invertApexBaseline(m map[string][]string) map[string][]string { r := make(map[string][]string) @@ -1969,9 +2095,8 @@ func BaselineApexAvailable(moduleName string) []string { return inverseApexAvailBaseline[normalizeModuleName(moduleName)] } -// This is a map from apex to modules, which overrides the -// apex_available setting for that particular module to make -// it available for the apex regardless of its setting. +// This is a map from apex to modules, which overrides the apex_available setting for that +// particular module to make it available for the apex regardless of its setting. // TODO(b/147364041): remove this func makeApexAvailableBaseline() map[string][]string { // The "Module separator"s below are employed to minimize merge conflicts. diff --git a/apex/builder.go b/apex/builder.go index acfb8c577..6f27dd179 100644 --- a/apex/builder.go +++ b/apex/builder.go @@ -195,8 +195,8 @@ func (a *apexBundle) buildManifest(ctx android.ModuleContext, provideNativeLibs, // collect jniLibs. Notice that a.filesInfo is already sorted var jniLibs []string for _, fi := range a.filesInfo { - if fi.isJniLib && !android.InList(fi.Stem(), jniLibs) { - jniLibs = append(jniLibs, fi.Stem()) + if fi.isJniLib && !android.InList(fi.stem(), jniLibs) { + jniLibs = append(jniLibs, fi.stem()) } } if len(jniLibs) > 0 { @@ -363,7 +363,7 @@ func (a *apexBundle) buildBundleConfig(ctx android.ModuleContext) android.Output config.Apex_config.Apex_embedded_apk_config, ApkConfig{ Package_name: packageName, - Apk_path: fi.Path(), + Apk_path: fi.path(), }) } } @@ -396,15 +396,15 @@ func (a *apexBundle) buildUnflattenedApex(ctx android.ModuleContext) { // TODO(jiyong): construct the copy rules using RuleBuilder var copyCommands []string for _, fi := range a.filesInfo { - destPath := android.PathForModuleOut(ctx, "image"+suffix, fi.Path()).String() + destPath := android.PathForModuleOut(ctx, "image"+suffix, fi.path()).String() destPathDir := filepath.Dir(destPath) if fi.class == appSet { copyCommands = append(copyCommands, "rm -rf "+destPathDir) } copyCommands = append(copyCommands, "mkdir -p "+destPathDir) - if a.linkToSystemLib && fi.transitiveDep && fi.AvailableToPlatform() { + if a.linkToSystemLib && fi.transitiveDep && fi.availableToPlatform() { // TODO(jiyong): pathOnDevice should come from fi.module, not being calculated here - pathOnDevice := filepath.Join("/system", fi.Path()) + pathOnDevice := filepath.Join("/system", fi.path()) copyCommands = append(copyCommands, "ln -sfn "+pathOnDevice+" "+destPath) } else { if fi.class == appSet { @@ -416,7 +416,7 @@ func (a *apexBundle) buildUnflattenedApex(ctx android.ModuleContext) { implicitInputs = append(implicitInputs, fi.builtFile) } // create additional symlinks pointing the file inside the APEX - for _, symlinkPath := range fi.SymlinkPaths() { + for _, symlinkPath := range fi.symlinkPaths() { symlinkDest := android.PathForModuleOut(ctx, "image"+suffix, symlinkPath).String() copyCommands = append(copyCommands, "ln -sfn "+filepath.Base(destPath)+" "+symlinkDest) } @@ -444,7 +444,7 @@ func (a *apexBundle) buildUnflattenedApex(ctx android.ModuleContext) { emitCommands = append(emitCommands, "echo ./apex_manifest.json >> "+imageContentFile.String()) } for _, fi := range a.filesInfo { - emitCommands = append(emitCommands, "echo './"+fi.Path()+"' >> "+imageContentFile.String()) + emitCommands = append(emitCommands, "echo './"+fi.path()+"' >> "+imageContentFile.String()) } emitCommands = append(emitCommands, "sort -o "+imageContentFile.String()+" "+imageContentFile.String()) implicitInputs = append(implicitInputs, a.manifestPbOut) @@ -489,7 +489,7 @@ func (a *apexBundle) buildUnflattenedApex(ctx android.ModuleContext) { var extractedAppSetPaths android.Paths var extractedAppSetDirs []string for _, f := range a.filesInfo { - pathInApex := f.Path() + pathInApex := f.path() if f.installDir == "bin" || strings.HasPrefix(f.installDir, "bin/") { executablePaths = append(executablePaths, pathInApex) for _, d := range f.dataPaths { @@ -697,6 +697,15 @@ func (a *apexBundle) buildUnflattenedApex(ctx android.ModuleContext) { a.installedFilesFile = a.buildInstalledFilesFile(ctx, a.outputFile, imageDir) } +// Context "decorator", overriding the InstallBypassMake method to always reply `true`. +type flattenedApexContext struct { + android.ModuleContext +} + +func (c *flattenedApexContext) InstallBypassMake() bool { + return true +} + func (a *apexBundle) buildFlattenedApex(ctx android.ModuleContext) { // Temporarily wrap the original `ctx` into a `flattenedApexContext` to have it // reply true to `InstallBypassMake()` (thus making the call @@ -742,7 +751,7 @@ func (a *apexBundle) buildFilesInfo(ctx android.ModuleContext) { apexBundleName := a.Name() for _, fi := range a.filesInfo { dir := filepath.Join("apex", apexBundleName, fi.installDir) - target := ctx.InstallFile(android.PathForModuleInstall(ctx, dir), fi.Stem(), fi.builtFile) + target := ctx.InstallFile(android.PathForModuleInstall(ctx, dir), fi.stem(), fi.builtFile) for _, sym := range fi.symlinks { ctx.InstallSymlink(android.PathForModuleInstall(ctx, dir), sym, target) }