[compiler-rt][hwasan] Support for new Intel LAM API

[glider]

Summary

New version of Intel LAM patches
(https://lore.kernel.org/linux-mm/[e-mail]/)
uses a different interface based on arch_prctl():

• arch_prctl(ARCH_GET_UNTAG_MASK, &mask) returns the current mask for untagging the pointers. We use it to detect kernel LAM support.
• arch_prctl(ARCH_ENABLE_TAGGED_ADDR, nr_bits) enables pointer tagging for the current process.

Because __NR_arch_prctl is defined in different headers, and no other
platforms need it at the moment, we only declare internal_arch_prctl()
on x86_64.

[vitalybuka]

compiler-rt/lib/hwasan/hwasan_linux.cpp

123–124

Maybe we want do CHECK that UNTAG_MASK matches out expectations?
something (hwsan_mask & ~arch_prctl_mask) == 0

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

766

do we need to guard this with if def?

compiler-rt/lib/hwasan/hwasan_linux.cpp

static void InitializeShadowBaseAddress(uptr shadow_size_bytes) {
   __hwasan_shadow_memory_dynamic_address =
       FindDynamicShadowStart(shadow_size_bytes);
 }
 
 void InitializeOsSupport() {
 #  define PR_SET_TAGGED_ADDR_CTRL 55
 #  define PR_GET_TAGGED_ADDR_CTRL 56
 #  define PR_TAGGED_ADDR_ENABLE (1UL << 0)
+#  define ARCH_GET_UNTAG_MASK     0x4001
+#  define ARCH_ENABLE_TAGGED_ADDR 0x4002
   // Check we're running on a kernel that can use the tagged address ABI.
   int local_errno = 0;
-  if (internal_iserror(internal_prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0),
+  bool has_abi;
+#  if defined(__x86_64__)
+  has_abi = (internal_iserror(internal_arch_prctl(ARCH_GET_UNTAG_MASK, 0),
                        &local_errno) &&
-      local_errno == EINVAL) {
+      local_errno == EINVAL);
+#  else
+  has_abi = (internal_iserror(internal_prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0),
+                       &local_errno) &&
+      local_errno == EINVAL);
+#  endif
+  if (has_abi) {
 #  if SANITIZER_ANDROID || defined(HWASAN_ALIASING_MODE)
     // Some older Android kernels have the tagged pointer ABI on
     // unconditionally, and hence don't have the tagged-addr prctl while still
     // allow the ABI.
     // If targeting Android and the prctl is not around we assume this is the
     // case.
     return;
 #  else
     if (flags()->fail_without_syscall_abi) {
       Printf(
           "FATAL: "
           "HWAddressSanitizer requires a kernel with tagged address ABI.\n");
       Die();
     }
 #  endif
   }
 
   // Turn on the tagged address ABI.
   if ((internal_iserror(internal_prctl(PR_SET_TAGGED_ADDR_CTRL,
                                        PR_TAGGED_ADDR_ENABLE, 0, 0, 0)) ||
        !internal_prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0))) {
 #  if defined(__x86_64__) && !defined(HWASAN_ALIASING_MODE)
     // Try the new prctl API for Intel LAM.  The API is based on a currently
-    // unsubmitted patch to the Linux kernel (as of May 2021) and is thus
+    // unsubmitted patch to the Linux kernel (as of July 2022) and is thus
     // subject to change.  Patch is here:
-    // https://lore.kernel.org/linux-mm/[e-mail]/
-    int tag_bits = kTagBits;
-    int tag_shift = kAddressTagShift;
+    // https://lore.kernel.org/linux-mm/[e-mail]/
     if (!internal_iserror(
-            internal_prctl(PR_SET_TAGGED_ADDR_CTRL, PR_TAGGED_ADDR_ENABLE,
-                           reinterpret_cast<unsigned long>(&tag_bits),
-                           reinterpret_cast<unsigned long>(&tag_shift), 0))) {
-      CHECK_EQ(tag_bits, kTagBits);
-      CHECK_EQ(tag_shift, kAddressTagShift);
+            internal_arch_prctl(ARCH_ENABLE_TAGGED_ADDR, kTagBits))) {
       return;
     }
 #  endif  // defined(__x86_64__) && !defined(HWASAN_ALIASING_MODE)
     if (flags()->fail_without_syscall_abi) {
       Printf(
           "FATAL: HWAddressSanitizer failed to enable tagged address syscall "
           "ABI.\nSuggest check `sysctl abi.tagged_addr_disabled` "
           "configuration.\n");

compiler-rt/lib/sanitizer_common/sanitizer_linux.h

 
 #  if SANITIZER_GLIBC
 uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp);
 #endif
 
 // Linux-only syscalls.
 #if SANITIZER_LINUX
 uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5);
+#    if defined(__x86_64__)
+uptr internal_arch_prctl(int option, uptr arg2);
+#    endif
 // Used only by sanitizer_stoptheworld. Signal handlers that are actually used
 // (like the process-wide error reporting SEGV handler) must use
 // internal_sigaction instead.
 int internal_sigaction_norestorer(int signum, const void *act, void *oldact);
 void internal_sigdelset(__sanitizer_sigset_t *set, int signum);
 #if defined(__x86_64__) || defined(__mips__) || defined(__aarch64__) || \
     defined(__powerpc64__) || defined(__s390__) || defined(__i386__) || \
     defined(__arm__) || SANITIZER_RISCV64

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

 uptr internal_lseek(fd_t fd, OFF_T offset, int whence) {
   return internal_syscall(SYSCALL(lseek), fd, offset, whence);
 }
 
 #if SANITIZER_LINUX
 uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5) {
   return internal_syscall(SYSCALL(prctl), option, arg2, arg3, arg4, arg5);
 }
+# if defined(__x86_64__)
+#include <asm/unistd_64.h>
+// Currently internal_arch_prctl() is only needed on x86_64.
+uptr internal_arch_prctl(int option, uptr arg2) {
+  return internal_syscall(__NR_arch_prctl, option, arg2);
+}
+# endif
 #endif
 
 uptr internal_sigaltstack(const void *ss, void *oss) {
   return internal_syscall(SYSCALL(sigaltstack), (uptr)ss, (uptr)oss);
 }
 
 int internal_fork() {
 #    if SANITIZER_LINUX