Restrict genrules to disallow directories as input (619be462) · Commits · e / os / android_build_soong

android/config.go

+4 −0

Original line number	Diff line number	Diff line
		@@ -1651,6 +1651,10 @@ func (c *deviceConfig) BuildBrokenVendorPropertyNamespace() bool {
		return c.config.productVariables.BuildBrokenVendorPropertyNamespace
		}

		func (c *deviceConfig) BuildBrokenInputDir(name string) bool {
		return InList(name, c.config.productVariables.BuildBrokenInputDirModules)
		}

		func (c *deviceConfig) RequiresInsecureExecmemForSwiftshader() bool {
		return c.config.productVariables.RequiresInsecureExecmemForSwiftshader
		}

android/paths.go

+79 −35

Original line number	Diff line number	Diff line
		@@ -405,6 +405,13 @@ func PathsForModuleSrc(ctx ModuleMissingDepsPathContext, paths []string) Paths {
		return PathsForModuleSrcExcludes(ctx, paths, nil)
		}

		type SourceInput struct {
		Context ModuleMissingDepsPathContext
		Paths []string
		ExcludePaths []string
		IncludeDirs bool
		}

		// PathsForModuleSrcExcludes returns a Paths{} containing the resolved references in paths, minus
		// those listed in excludes. Elements of paths and excludes are resolved as:
		// * filepath, relative to local module directory, resolves as a filepath relative to the local
		@@ -423,12 +430,21 @@ func PathsForModuleSrc(ctx ModuleMissingDepsPathContext, paths []string) Paths {
		// missing dependencies
		// * otherwise, a ModuleError is thrown.
		func PathsForModuleSrcExcludes(ctx ModuleMissingDepsPathContext, paths, excludes []string) Paths {
		ret, missingDeps := PathsAndMissingDepsForModuleSrcExcludes(ctx, paths, excludes)
		if ctx.Config().AllowMissingDependencies() {
		ctx.AddMissingDependencies(missingDeps)
		return PathsRelativeToModuleSourceDir(SourceInput{
		Context: ctx,
		Paths: paths,
		ExcludePaths: excludes,
		IncludeDirs: true,
		})
		}

		func PathsRelativeToModuleSourceDir(input SourceInput) Paths {
		ret, missingDeps := PathsAndMissingDepsRelativeToModuleSourceDir(input)
		if input.Context.Config().AllowMissingDependencies() {
		input.Context.AddMissingDependencies(missingDeps)
		} else {
		for _, m := range missingDeps {
		ctx.ModuleErrorf(`missing dependency on %q, is the property annotated with android:"path"?`, m)
		input.Context.ModuleErrorf(`missing dependency on %q, is the property annotated with android:"path"?`, m)
		}
		}
		return ret
		@@ -543,23 +559,31 @@ func GetModuleFromPathDep(ctx ModuleWithDepsPathContext, moduleName, tag string)
		// Properties passed as the paths argument must have been annotated with struct tag
		// `android:"path"` so that dependencies on SourceFileProducer modules will have already been handled by the
		// path_deps mutator.
		func PathsAndMissingDepsForModuleSrcExcludes(ctx ModuleWithDepsPathContext, paths, excludes []string) (Paths, []string) {
		prefix := pathForModuleSrc(ctx).String()
		func PathsAndMissingDepsForModuleSrcExcludes(ctx ModuleMissingDepsPathContext, paths, excludes []string) (Paths, []string) {
		return PathsAndMissingDepsRelativeToModuleSourceDir(SourceInput{
		Context: ctx,
		Paths: paths,
		ExcludePaths: excludes,
		IncludeDirs: true,
		})
		}

		func PathsAndMissingDepsRelativeToModuleSourceDir(input SourceInput) (Paths, []string) {
		prefix := pathForModuleSrc(input.Context).String()

		var expandedExcludes []string
		if excludes != nil {
		expandedExcludes = make([]string, 0, len(excludes))
		if input.ExcludePaths != nil {
		expandedExcludes = make([]string, 0, len(input.ExcludePaths))
		}

		var missingExcludeDeps []string

		for _, e := range excludes {
		for _, e := range input.ExcludePaths {
		if m, t := SrcIsModuleWithTag(e); m != "" {
		modulePaths, err := getPathsFromModuleDep(ctx, e, m, t)
		modulePaths, err := getPathsFromModuleDep(input.Context, e, m, t)
		if m, ok := err.(missingDependencyError); ok {
		missingExcludeDeps = append(missingExcludeDeps, m.missingDeps...)
		} else if err != nil {
		reportPathError(ctx, err)
		reportPathError(input.Context, err)
		} else {
		expandedExcludes = append(expandedExcludes, modulePaths.Strings()...)
		}
		@@ -568,19 +592,24 @@ func PathsAndMissingDepsForModuleSrcExcludes(ctx ModuleWithDepsPathContext, path
		}
		}

		if paths == nil {
		if input.Paths == nil {
		return nil, missingExcludeDeps
		}

		var missingDeps []string

		expandedSrcFiles := make(Paths, 0, len(paths))
		for _, s := range paths {
		srcFiles, err := expandOneSrcPath(ctx, s, expandedExcludes)
		expandedSrcFiles := make(Paths, 0, len(input.Paths))
		for _, s := range input.Paths {
		srcFiles, err := expandOneSrcPath(sourcePathInput{
		context: input.Context,
		path: s,
		expandedExcludes: expandedExcludes,
		includeDirs: input.IncludeDirs,
		})
		if depErr, ok := err.(missingDependencyError); ok {
		missingDeps = append(missingDeps, depErr.missingDeps...)
		} else if err != nil {
		reportPathError(ctx, err)
		reportPathError(input.Context, err)
		}
		expandedSrcFiles = append(expandedSrcFiles, srcFiles...)
		}
		@@ -596,46 +625,61 @@ func (e missingDependencyError) Error() string {
		return "missing dependencies: " + strings.Join(e.missingDeps, ", ")
		}

		type sourcePathInput struct {
		context ModuleWithDepsPathContext
		path string
		expandedExcludes []string
		includeDirs bool
		}

		// Expands one path string to Paths rooted from the module's local source
		// directory, excluding those listed in the expandedExcludes.
		// Expands globs, references to SourceFileProducer or OutputFileProducer modules using the ":name" and ":name{.tag}" syntax.
		func expandOneSrcPath(ctx ModuleWithDepsPathContext, sPath string, expandedExcludes []string) (Paths, error) {
		func expandOneSrcPath(input sourcePathInput) (Paths, error) {
		excludePaths := func(paths Paths) Paths {
		if len(expandedExcludes) == 0 {
		if len(input.expandedExcludes) == 0 {
		return paths
		}
		remainder := make(Paths, 0, len(paths))
		for _, p := range paths {
		if !InList(p.String(), expandedExcludes) {
		if !InList(p.String(), input.expandedExcludes) {
		remainder = append(remainder, p)
		}
		}
		return remainder
		}
		if m, t := SrcIsModuleWithTag(sPath); m != "" {
		modulePaths, err := getPathsFromModuleDep(ctx, sPath, m, t)
		if m, t := SrcIsModuleWithTag(input.path); m != "" {
		modulePaths, err := getPathsFromModuleDep(input.context, input.path, m, t)
		if err != nil {
		return nil, err
		} else {
		return excludePaths(modulePaths), nil
		}
		} else if pathtools.IsGlob(sPath) {
		paths := GlobFiles(ctx, pathForModuleSrc(ctx, sPath).String(), expandedExcludes)
		return PathsWithModuleSrcSubDir(ctx, paths, ""), nil
		} else {
		p := pathForModuleSrc(ctx, sPath)
		if exists, _, err := ctx.Config().fs.Exists(p.String()); err != nil {
		ReportPathErrorf(ctx, "%s: %s", p, err.Error())
		} else if !exists && !ctx.Config().TestAllowNonExistentPaths {
		ReportPathErrorf(ctx, "module source path %q does not exist", p)
		p := pathForModuleSrc(input.context, input.path)
		if pathtools.IsGlob(input.path) {
		paths := GlobFiles(input.context, p.String(), input.expandedExcludes)
		return PathsWithModuleSrcSubDir(input.context, paths, ""), nil
		} else {
		if exists, _, err := input.context.Config().fs.Exists(p.String()); err != nil {
		ReportPathErrorf(input.context, "%s: %s", p, err.Error())
		} else if !exists && !input.context.Config().TestAllowNonExistentPaths {
		ReportPathErrorf(input.context, "module source path %q does not exist", p)
		} else if !input.includeDirs {
		if isDir, err := input.context.Config().fs.IsDir(p.String()); exists && err != nil {
		ReportPathErrorf(input.context, "%s: %s", p, err.Error())
		} else if isDir {
		ReportPathErrorf(input.context, "module source path %q is a directory", p)
		}
		}

		if InList(p.String(), expandedExcludes) {
		if InList(p.String(), input.expandedExcludes) {
		return nil, nil
		}
		return Paths{p}, nil
		}
		}
		}

		// pathsForModuleSrcFromFullPath returns Paths rooted from the module's local
		// source directory, but strip the local source directory from the beginning of
		@@ -1315,7 +1359,7 @@ func PathForModuleSrc(ctx ModuleMissingDepsPathContext, pathComponents ...string
		// validatePath() will corrupt it, e.g. replace "//" with "/". If the path is not a module
		// reference then it will be validated by expandOneSrcPath anyway when it calls expandOneSrcPath.
		p := strings.Join(pathComponents, string(filepath.Separator))
		paths, err := expandOneSrcPath(ctx, p, nil)
		paths, err := expandOneSrcPath(sourcePathInput{context: ctx, path: p, includeDirs: true})
		if err != nil {
		if depErr, ok := err.(missingDependencyError); ok {
		if ctx.Config().AllowMissingDependencies() {

android/variable.go

+4 −3

Original line number	Diff line number	Diff line
		@@ -424,6 +424,7 @@ type productVariables struct {
		BuildBrokenEnforceSyspropOwner bool `json:",omitempty"`
		BuildBrokenTrebleSyspropNeverallow bool `json:",omitempty"`
		BuildBrokenVendorPropertyNamespace bool `json:",omitempty"`
		BuildBrokenInputDirModules []string `json:",omitempty"`

		BuildDebugfsRestrictionsEnabled bool `json:",omitempty"`

genrule/genrule.go

+4 −1

Original line number	Diff line number	Diff line
		@@ -382,9 +382,12 @@ func (g *Module) GenerateAndroidBuildActions(ctx android.ModuleContext) {
		addLocationLabel(toolFile, toolLocation{paths})
		}

		includeDirInPaths := ctx.DeviceConfig().BuildBrokenInputDir(g.Name())
		var srcFiles android.Paths
		for _, in := range g.properties.Srcs {
		paths, missingDeps := android.PathsAndMissingDepsForModuleSrcExcludes(ctx, []string{in}, g.properties.Exclude_srcs)
		paths, missingDeps := android.PathsAndMissingDepsRelativeToModuleSourceDir(android.SourceInput{
		Context: ctx, Paths: []string{in}, ExcludePaths: g.properties.Exclude_srcs, IncludeDirs: includeDirInPaths,
		})
		if len(missingDeps) > 0 {
		if !ctx.Config().AllowMissingDependencies() {
		panic(fmt.Errorf("should never get here, the missing dependencies %q should have been reported in DepsMutator",