Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 447f5b1e authored by Ivan Lozano's avatar Ivan Lozano
Browse files

rust: Add SCS sanitizer option. 

SCS has been supported in Rust since 1.64.0.

This adds SCS as a sanitizer option in Rust.

Bug: 168914033
Test: Built module with sanitize: { scs: true }
Change-Id: Ibdc116a335339af6d0b0d6dd0bb82c0358fa9087
parent f7bd2592

cc/sanitize.go

+11 −11
Original line number Diff line number Diff line
@@ -100,7 +100,7 @@ const ( 
	Hwasan

	tsan

	intOverflow

	scs

	Scs

	Fuzzer

	Memtag_heap

	Memtag_stack
@@ -113,7 +113,7 @@ var Sanitizers = []SanitizerType{ 
	Hwasan,

	tsan,

	intOverflow,

	scs,

	Scs,

	Fuzzer,

	Memtag_heap,

	Memtag_stack,
@@ -134,7 +134,7 @@ func (t SanitizerType) variationName() string { 
		return "intOverflow"

	case cfi:

		return "cfi"

	case scs:

	case Scs:

		return "scs"

	case Memtag_heap:

		return "memtag_heap"
@@ -168,7 +168,7 @@ func (t SanitizerType) name() string { 
		return "integer_overflow"

	case cfi:

		return "cfi"

	case scs:

	case Scs:

		return "shadow-call-stack"

	case Fuzzer:

		return "fuzzer"
@@ -179,7 +179,7 @@ func (t SanitizerType) name() string { 


func (t SanitizerType) registerMutators(ctx android.RegisterMutatorsContext) {

	switch t {

	case cfi, Hwasan, Asan, tsan, Fuzzer, scs:

	case cfi, Hwasan, Asan, tsan, Fuzzer, Scs:

		sanitizer := &sanitizerSplitMutator{t}

		ctx.TopDown(t.variationName()+"_markapexes", sanitizer.markSanitizableApexesMutator)

		ctx.Transition(t.variationName(), sanitizer)
@@ -216,7 +216,7 @@ func (*Module) SanitizerSupported(t SanitizerType) bool { 
		return true

	case cfi:

		return true

	case scs:

	case Scs:

		return true

	case Fuzzer:

		return true
@@ -1022,7 +1022,7 @@ func (s *sanitize) getSanitizerBoolPtr(t SanitizerType) *bool { 
		return s.Properties.SanitizeMutated.Integer_overflow

	case cfi:

		return s.Properties.SanitizeMutated.Cfi

	case scs:

	case Scs:

		return s.Properties.SanitizeMutated.Scs

	case Memtag_heap:

		return s.Properties.SanitizeMutated.Memtag_heap
@@ -1043,7 +1043,7 @@ func (sanitize *sanitize) isUnsanitizedVariant() bool { 
		!sanitize.isSanitizerEnabled(Hwasan) &&

		!sanitize.isSanitizerEnabled(tsan) &&

		!sanitize.isSanitizerEnabled(cfi) &&

		!sanitize.isSanitizerEnabled(scs) &&

		!sanitize.isSanitizerEnabled(Scs) &&

		!sanitize.isSanitizerEnabled(Memtag_heap) &&

		!sanitize.isSanitizerEnabled(Memtag_stack) &&

		!sanitize.isSanitizerEnabled(Memtag_globals) &&
@@ -1080,7 +1080,7 @@ func (sanitize *sanitize) SetSanitizer(t SanitizerType, b bool) { 
		sanitize.Properties.SanitizeMutated.Integer_overflow = bPtr

	case cfi:

		sanitize.Properties.SanitizeMutated.Cfi = bPtr

	case scs:

	case Scs:

		sanitize.Properties.SanitizeMutated.Scs = bPtr

	case Memtag_heap:

		sanitize.Properties.SanitizeMutated.Memtag_heap = bPtr
@@ -1340,7 +1340,7 @@ func (s *sanitizerSplitMutator) Mutate(mctx android.BottomUpMutatorContext, vari 


		oneMakeVariation := false

		if c.StaticallyLinked() || c.Header() {

			if s.sanitizer != cfi && s.sanitizer != scs && s.sanitizer != Hwasan {

			if s.sanitizer != cfi && s.sanitizer != Scs && s.sanitizer != Hwasan {

				// These sanitizers export only one variation to Make. For the rest,

				// Make targets can depend on both the sanitized and non-sanitized

				// versions.
@@ -1350,7 +1350,7 @@ func (s *sanitizerSplitMutator) Mutate(mctx android.BottomUpMutatorContext, vari 
			// Shared library. These are the sanitizers that do propagate through shared

			// library dependencies and therefore can cause multiple variations of a

			// shared library to be built.

			if s.sanitizer != cfi && s.sanitizer != Hwasan && s.sanitizer != scs && s.sanitizer != Asan {

			if s.sanitizer != cfi && s.sanitizer != Hwasan && s.sanitizer != Scs && s.sanitizer != Asan {

				oneMakeVariation = true

			}

		}

cc/vendor_snapshot.go

+1 −1
Original line number Diff line number Diff line
@@ -95,7 +95,7 @@ func isSnapshotAware(cfg android.DeviceConfig, m LinkableInterface, inProprietar 
		if sanitizable.SanitizePropDefined() {

			// scs exports both sanitized and unsanitized variants for static and header

			// Always use unsanitized variant of it.

			if !sanitizable.Shared() && sanitizable.IsSanitizerEnabled(scs) {

			if !sanitizable.Shared() && sanitizable.IsSanitizerEnabled(Scs) {

				return false

			}

			// cfi and hwasan also export both variants. But for static, we capture both.

rust/sanitize.go

+24 −1
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ type SanitizeProperties struct { 
	Sanitize struct {

		Address   *bool `android:"arch_variant"`

		Hwaddress *bool `android:"arch_variant"`

		Scs       *bool `android:"arch_variant"`



		// Memory-tagging, only available on arm64

		// if diag.memtag unset or false, enables async memory tagging
@@ -75,6 +76,9 @@ var fuzzerFlags = []string{ 
var asanFlags = []string{

	"-Z sanitizer=address",

}

var scsFlags = []string{

	"-Z sanitizer=shadow-call-stack",

}



// See cc/sanitize.go's hwasanGlobalOptions for global hwasan options.

var hwasanFlags = []string{
@@ -208,9 +212,14 @@ func (sanitize *sanitize) begin(ctx BaseModuleContext) { 
		s.Memtag_heap = nil

	}



	// SCS is only implemented on AArch64/riscv64.

	if (ctx.Arch().ArchType != android.Arm64 && ctx.Arch().ArchType != android.Riscv64) || !ctx.toolchain().Bionic() {

		s.Scs = nil

	}



	// TODO:(b/178369775)

	// For now sanitizing is only supported on devices

	if ctx.Os() == android.Android && (Bool(s.Hwaddress) || Bool(s.Address) || Bool(s.Memtag_heap) || Bool(s.Fuzzer)) {

	if ctx.Os() == android.Android && (Bool(s.Hwaddress) || Bool(s.Address) || Bool(s.Memtag_heap) || Bool(s.Fuzzer) || Bool(s.Scs)) {

		sanitize.Properties.SanitizerEnabled = true

	}

}
@@ -229,7 +238,10 @@ func (sanitize *sanitize) flags(ctx ModuleContext, flags Flags, deps PathDeps) ( 
		flags.RustFlags = append(flags.RustFlags, hwasanFlags...)

	} else if Bool(sanitize.Properties.Sanitize.Address) {

		flags.RustFlags = append(flags.RustFlags, asanFlags...)

	} else if Bool(sanitize.Properties.Sanitize.Scs) {

		flags.RustFlags = append(flags.RustFlags, scsFlags...)

	}



	return flags, deps

}
@@ -311,6 +323,9 @@ func (sanitize *sanitize) SetSanitizer(t cc.SanitizerType, b bool) { 
	case cc.Memtag_heap:

		sanitize.Properties.Sanitize.Memtag_heap = boolPtr(b)

		sanitizerSet = true

	case cc.Scs:

		sanitize.Properties.Sanitize.Scs = boolPtr(b)

		sanitizerSet = true

	default:

		panic(fmt.Errorf("setting unsupported sanitizerType %d", t))

	}
@@ -372,6 +387,8 @@ func (sanitize *sanitize) getSanitizerBoolPtr(t cc.SanitizerType) *bool { 
		return sanitize.Properties.Sanitize.Hwaddress

	case cc.Memtag_heap:

		return sanitize.Properties.Sanitize.Memtag_heap

	case cc.Scs:

		return sanitize.Properties.Sanitize.Scs

	default:

		return nil

	}
@@ -384,6 +401,10 @@ func (sanitize *sanitize) AndroidMk(ctx AndroidMkContext, entries *android.Andro 
		if sanitize.isSanitizerEnabled(cc.Hwasan) {

			entries.SubName += ".hwasan"

		}

		if sanitize.isSanitizerEnabled(cc.Scs) {

			entries.SubName += ".scs"

		}



	}

}
@@ -404,6 +425,8 @@ func (mod *Module) SanitizerSupported(t cc.SanitizerType) bool { 
		return true

	case cc.Memtag_heap:

		return true

	case cc.Scs:

		return true

	default:

		return false

	}