[scudo] Enable MTE in Trusty

[ahomescu]

Summary

Trusty now has MTE support.
Back-ported from https://r.android.com/2332745.

[ahomescu]

Added link to original Trusty CL.

[ahomescu]

Updated summary.

[Chia-hungDuan]

compiler-rt/lib/scudo/standalone/memtag.h

14

I suggest using SCUDO_CAN_USE_MTE and define this in platform.h

[ahomescu]

Define SCUDO_CAN_USE_MTE in platform.h.

[ahomescu]

compiler-rt/lib/scudo/standalone/platform.h

46

Should every architecture define SCUDO_CAN_USE_MTE itself, or leave it like this?

[ahomescu]

Replaced last SCUDO_MTE.

[Chia-hungDuan]

compiler-rt/lib/scudo/standalone/platform.h

46

This form looks good to me. Can we move this below SCUDO_CAN_USE_PRIMARY64?

[ahomescu]

Moved and updated definition of SCUDO_CAN_USE_MTE.

compiler-rt/lib/scudo/standalone/allocator_config.h

#endif
 
   struct Secondary {
     template <typename Config> using CacheT = MapAllocatorNoCache<Config>;
   };
   template <typename Config> using SecondaryT = MapAllocator<Config>;
 };
 
 struct TrustyConfig {
-  static const bool MaySupportMemoryTagging = false;
+  static const bool MaySupportMemoryTagging = true;
   template <class A>
   using TSDRegistryT = TSDRegistrySharedT<A, 1U, 1U>; // Shared, max 1 TSD.
 
   struct Primary {
     using SizeClassMap = TrustySizeClassMap;
     static const uptr RegionSizeLog = 28U;
     static const uptr GroupSizeLog = 20U;
     typedef u32 CompactPtrT;

compiler-rt/lib/scudo/standalone/memtag.h

 //===-- memtag.h ------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SCUDO_MEMTAG_H_
 #define SCUDO_MEMTAG_H_
 
 #include "internal_defs.h"
 
-#if SCUDO_LINUX
+#if SCUDO_CAN_USE_MTE
 #include <sys/auxv.h>
 #include <sys/prctl.h>
 #endif
 
 namespace scudo {
 
 #if (__clang_major__ >= 12 && defined(__aarch64__) && !defined(__ILP32__)) ||  \
     defined(SCUDO_FUZZ)
 
 // We assume that Top-Byte Ignore is enabled if the architecture supports memory
 // tagging. Not all operating systems enable TBI, so we only claim architectural
 // support for memory tagging if the operating system enables TBI.
 // HWASan uses the top byte for its own purpose and Scudo should not touch it.
-#if SCUDO_LINUX && !defined(SCUDO_DISABLE_TBI) &&                              \
+#if SCUDO_CAN_USE_MTE && !defined(SCUDO_DISABLE_TBI) &&                        \
     !__has_feature(hwaddress_sanitizer)
 inline constexpr bool archSupportsMemoryTagging() { return true; }
 #else
 inline constexpr bool archSupportsMemoryTagging() { return false; }
 #endif
 
 inline constexpr uptr archMemoryTagGranuleSize() { return 16; }
 
inline NORETURN uint8_t extractTag(uptr Ptr) {
   (void)Ptr;
   UNREACHABLE("memory tagging not supported");
 }
 
 #endif
 
 #if __clang_major__ >= 12 && defined(__aarch64__) && !defined(__ILP32__)
 
-#if SCUDO_LINUX
+#if SCUDO_CAN_USE_MTE
 
 inline bool systemSupportsMemoryTagging() {
 #ifndef HWCAP2_MTE
 #define HWCAP2_MTE (1 << 18)
 #endif
   return getauxval(AT_HWCAP2) & HWCAP2_MTE;
 }
 

 }
 
 inline void enableSystemMemoryTaggingTestOnly() {
   prctl(PR_SET_TAGGED_ADDR_CTRL,
         PR_TAGGED_ADDR_ENABLE | PR_MTE_TCF_SYNC | (0xfffe << PR_MTE_TAG_SHIFT),
         0, 0, 0);
 }
 
-#else // !SCUDO_LINUX
+#else // !SCUDO_CAN_USE_MTE
 
 inline bool systemSupportsMemoryTagging() { return false; }
 
 inline NORETURN bool systemDetectsMemoryTagFaultsTestOnly() {
   UNREACHABLE("memory tagging not supported");
 }
 
 inline NORETURN void enableSystemMemoryTaggingTestOnly() {
   UNREACHABLE("memory tagging not supported");
 }
 
-#endif // SCUDO_LINUX
+#endif // SCUDO_CAN_USE_MTE
 
 class ScopedDisableMemoryTagChecks {
   uptr PrevTCO;
 
 public:
   ScopedDisableMemoryTagChecks() {
     __asm__ __volatile__(
         R"(

compiler-rt/lib/scudo/standalone/platform.h

 #endif
 
 #if defined(__riscv) && (__riscv_xlen == 64)
 #define SCUDO_RISCV64 1
 #else
 #define SCUDO_RISCV64 0
 #endif
 
 #if defined(__LP64__)
 #define SCUDO_WORDSIZE 64U
 #else
 #define SCUDO_WORDSIZE 32U
 #endif
 
 #if SCUDO_WORDSIZE == 64U
 #define FIRST_32_SECOND_64(a, b) (b)
 #else
 #define FIRST_32_SECOND_64(a, b) (a)
 #endif
 
 #ifndef SCUDO_CAN_USE_PRIMARY64
 #define SCUDO_CAN_USE_PRIMARY64 (SCUDO_WORDSIZE == 64U)
 #endif
 
+#ifndef SCUDO_CAN_USE_MTE
+#define SCUDO_CAN_USE_MTE (SCUDO_LINUX || SCUDO_TRUSTY)
+#endif
+
 #ifndef SCUDO_MIN_ALIGNMENT_LOG
 // We force malloc-type functions to be aligned to std::max_align_t, but there
 // is no reason why the minimum alignment for all other functions can't be 8
 // bytes. Except obviously for applications making incorrect assumptions.
 // TODO(kostyak): define SCUDO_MIN_ALIGNMENT_LOG 3
 #define SCUDO_MIN_ALIGNMENT_LOG FIRST_32_SECOND_64(3, 4)
 #endif
 

compiler-rt/lib/scudo/standalone/trusty.cpp

void *map(void *Addr, uptr Size, const char *Name, uptr Flags,
   // If the MAP_NOACCESS flag is set, Scudo tries to reserve
   // a memory region without mapping physical pages. This corresponds
   // to MMAP_FLAG_NO_PHYSICAL in Trusty.
   if (Flags & MAP_NOACCESS)
     MmapFlags |= MMAP_FLAG_NO_PHYSICAL;
   if (Addr)
     MmapFlags |= MMAP_FLAG_FIXED_NOREPLACE;
 
+  if (Flags & MAP_MEMTAG)
+    MmapFlags |= MMAP_FLAG_PROT_MTE;
+
   void *P = (void *)_trusty_mmap(Addr, Size, MmapFlags, 0);
 
   if (IS_ERR(P)) {
     errno = lk_err_to_errno(PTR_ERR(P));
     dieOnMapUnmapError(Size);
     return nullptr;
   }