[Darwin] Add and adopt a way to query for the Darwin kernel version

[yln]

Summary

This applies the learnings from [1]. What I intended as a simple
cleanup made me realize that the compiler-rt version checks have two
separate issues:

1. In some places (e.g., mmap flag setting) what matters is the kernel version, not the OS version.
2. OS version checks are implemented by querying the kernel version. This is not necessarily correct inside the simulators if the simulator runtime isn't aligned the host macOS.

This commit tackles 1) by adopting a separate query function for the
Darwin kernel version. 2) (and cleanups) will be dealt with in
follow-ups.

[1] https://reviews.llvm.org/D78942

rdar://63031937

[yln]

Issue 2) is addressed by D79979

[yln]

compiler-rt/lib/sanitizer_common/sanitizer_mac.cpp

671

Any suggestions on how to improve this parsing code? compiler-rt shouldn't use sscanf() and there is no internal_sscanf().

[delcypher]

The overall idea looks good but I think the current patch has a few bugs.

compiler-rt/lib/sanitizer_common/sanitizer_mac.cpp

663

Are you sure that's the correct syctl?

On my system

$ sysctl -a | grep kern.osproductversion
kern.osproductversion: 10.15.5

That looks like the OS version rather than the kernel version.

Perhaps you meant

$ sysctl -a | grep kern.osrelease
kern.osrelease: 19.5.0

?

671

Do you need to advance p by 1 before the second call to internal_simple_strtoll? At that point it still points at '.' which isn't an integer.

[delcypher]

Suggestion: You could write a Darwin only unit test that calls GetDarwinKernelVersion() and checks the result matches the kernel reported by the host.

[delcypher]

Suggestion: You could also write a small Darwin only unit test that tests DarwinKernelVersion operators.

compiler-rt/lib/sanitizer_common/sanitizer_mac.h

57

Suggestion. You could instead implement operator> and then implement operator>= as

bool operator>=(const DarwinKernelVersion &other) const {
  return *this == other || *this > other;
}

[yln]

In D79965#2048133, @delcypher wrote:

Suggestion: You could write a Darwin only unit test that calls GetDarwinKernelVersion() and checks the result matches the kernel reported by the host.

I will add a test for GetDarwinKernelVersion() and the existing GetMacosVersion() in a follow-up patch.

compiler-rt/lib/sanitizer_common/sanitizer_mac.cpp

663

Ahh, of course! That's the whole point of the patch. :facepalm:

671

Thanks, fixed!

compiler-rt/lib/sanitizer_common/sanitizer_mac.h

57

In the distant future, all of this can just be auto operator<=>(const Version&) const = default;
https://en.cppreference.com/w/cpp/language/default_comparisons

[yln]

Use appropriate sysctl key kern.osrelease. Fix bug in parsing code.

[delcypher]

LGTM

compiler-rt/lib/sanitizer_common/sanitizer_mac.h

enum MacosVersion {
   MACOS_VERSION_UNKNOWN,
   MACOS_VERSION_LION,  // macOS 10.7; oldest currently supported
   MACOS_VERSION_MOUNTAIN_LION,
   MACOS_VERSION_MAVERICKS,
   MACOS_VERSION_YOSEMITE,
   MACOS_VERSION_EL_CAPITAN,
   MACOS_VERSION_SIERRA,
   MACOS_VERSION_HIGH_SIERRA,
-  MACOS_VERSION_HIGH_SIERRA_DOT_RELEASE_4,
   MACOS_VERSION_MOJAVE,
   MACOS_VERSION_CATALINA,
   MACOS_VERSION_UNKNOWN_NEWER
 };
 
+struct DarwinKernelVersion {
+  u16 major;
+  u16 minor;
+
+  DarwinKernelVersion(u16 major, u16 minor) : major(major), minor(minor) {}
+
+  bool operator==(const DarwinKernelVersion &other) const {
+    return major == other.major && minor == other.minor;
+  }
+  bool operator>=(const DarwinKernelVersion &other) const {
+    return major >= other.major ||
+           (major == other.major && minor >= other.minor);
+  }
+};
+
 MacosVersion GetMacosVersion();
+DarwinKernelVersion GetDarwinKernelVersion();
 
 char **GetEnviron();
 
 void RestrictMemoryToMaxAddress(uptr max_address);
 
 }  // namespace __sanitizer
 
 extern "C" {

compiler-rt/lib/sanitizer_common/sanitizer_mac.cpp

MacosVersion GetMacosVersionInternal() {
 
   switch (major) {
     case 11: return MACOS_VERSION_LION;
     case 12: return MACOS_VERSION_MOUNTAIN_LION;
     case 13: return MACOS_VERSION_MAVERICKS;
     case 14: return MACOS_VERSION_YOSEMITE;
     case 15: return MACOS_VERSION_EL_CAPITAN;
     case 16: return MACOS_VERSION_SIERRA;
-    case 17:
-      // Not a typo, 17.5 Darwin Kernel Version maps to High Sierra 10.13.4.
-      if (minor >= 5)
-        return MACOS_VERSION_HIGH_SIERRA_DOT_RELEASE_4;
-      return MACOS_VERSION_HIGH_SIERRA;
+    case 17: return MACOS_VERSION_HIGH_SIERRA;
     case 18: return MACOS_VERSION_MOJAVE;
     case 19: return MACOS_VERSION_CATALINA;
     default:
       if (major < 9) return MACOS_VERSION_UNKNOWN;
       return MACOS_VERSION_UNKNOWN_NEWER;
   }
 }
 
 MacosVersion GetMacosVersion() {
   atomic_uint32_t *cache =
       reinterpret_cast<atomic_uint32_t*>(&cached_macos_version);
   MacosVersion result =
       static_cast<MacosVersion>(atomic_load(cache, memory_order_acquire));
   if (result == MACOS_VERSION_UNINITIALIZED) {
     result = GetMacosVersionInternal();
     atomic_store(cache, result, memory_order_release);
   }
   return result;
 }
 
+DarwinKernelVersion GetDarwinKernelVersion() {
+  char buf[100];
+  size_t len = sizeof(buf);
+  int res = internal_sysctlbyname("kern.osrelease", buf, &len, nullptr, 0);
+  CHECK_EQ(res, 0);
+
+  // Format: <major>.<minor>.<patch>\0
+  CHECK_GE(len, 6);
+  const char *p = buf;
+  u16 major = internal_simple_strtoll(p, &p, /*base=*/10);
+  CHECK_EQ(*p, '.');
+  p += 1;
+  u16 minor = internal_simple_strtoll(p, &p, /*base=*/10);
+
+  return DarwinKernelVersion(major, minor);
+}
+
 uptr GetRSS() {
   struct task_basic_info info;
   unsigned count = TASK_BASIC_INFO_COUNT;
   kern_return_t result =
       task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &count);
   if (UNLIKELY(result != KERN_SUCCESS)) {
     Report("Cannot get task info. Error: %d\n", result);
     Die();

 }
 
 void SignalContext::InitPcSpBp() {
   addr = (uptr)ptrauth_strip((void *)addr, 0);
   GetPcSpBp(context, &pc, &sp, &bp);
 }
 
 void InitializePlatformEarly() {
-  // Only use xnu_fast_mmap when on x86_64 and the OS supports it.
+  // Only use xnu_fast_mmap when on x86_64 and the kernel supports it.
   use_xnu_fast_mmap =
 #if defined(__x86_64__)
-      GetMacosVersion() >= MACOS_VERSION_HIGH_SIERRA_DOT_RELEASE_4;
+      GetDarwinKernelVersion() >= DarwinKernelVersion(17, 5);
 #else
       false;
 #endif
 }
 
 #if !SANITIZER_GO
 static const char kDyldInsertLibraries[] = "DYLD_INSERT_LIBRARIES";
 LowLevelAllocator allocator_for_env;