databases/mongodb80: reimplement waitable_atomic.cpp

Reimplement src/mongo/platform/waitable_atomic.cpp using absolute time.
This uses more simple conversions.
The implementation is now similar to the Linux version instead of the
MacOS version.

It should not have any functional change.

Reported by:	https://infosec.exchange/@david_chisnall/113797905538197081
Reported by:	mongodb/mongo#1607 (comment)

Author: ronaldklop

databases/mongodb80/Makefile

@@ -1,7 +1,7 @@
 PORTNAME=	mongodb
 DISTVERSIONPREFIX=	r
 DISTVERSION=	8.0.4
-PORTREVISION=	2
+PORTREVISION=	3
 CATEGORIES=	databases net
 MASTER_SITES=	https://hg.mozilla.org/mozilla-central/raw-rev/:patches
 PKGNAMESUFFIX=	${DISTVERSION:R:S/.//}

databases/mongodb80/files/patch-src_mongo_platform_waitable__atomic.cpp

@@ -1,4 +1,4 @@
---- src/mongo/platform/waitable_atomic.cpp.orig	2024-07-23 11:53:14 UTC
+--- src/mongo/platform/waitable_atomic.cpp.orig	2024-11-20 23:53:48 UTC
 +++ src/mongo/platform/waitable_atomic.cpp
 @@ -34,6 +34,9 @@
  #ifdef __linux__
@@ -10,56 +10,49 @@
  #elif defined(_WIN32)
  #include <synchapi.h>
  #endif
-@@ -228,6 +231,52 @@ bool waitUntil(const void* uaddr,
-     }
- 
-     if (__ulock_wait(UL_COMPARE_AND_WAIT, const_cast<void*>(uaddr), old, timeoutMicros) != -1)
-+        return true;
-+
-+    // There isn't a good list of possible errors, so assuming that anything other than a timeout
-+    // error is a possible spurious wakeup.
-+    return timeoutOverflow || errno != ETIMEDOUT;
+@@ -233,6 +236,45 @@ bool waitUntil(const void* uaddr,
+     // There isn't a good list of possible errors, so assuming that anything other than a timeout
+     // error is a possible spurious wakeup.
+     return timeoutOverflow || errno != ETIMEDOUT;
 +}
 +
 +#elif defined(__FreeBSD__)
 +
 +void notifyOne(const void* uaddr) {
-+    _umtx_op(const_cast<void*>(uaddr), UMTX_OP_WAKE, 1, NULL, NULL);
++    _umtx_op(const_cast<void*>(uaddr), UMTX_OP_WAKE_PRIVATE, 1, NULL, NULL);
 +}
 +
 +void notifyMany(const void* uaddr, int nToWake) {
-+    _umtx_op(const_cast<void*>(uaddr), UMTX_OP_WAKE, nToWake, NULL, NULL);
++    _umtx_op(const_cast<void*>(uaddr), UMTX_OP_WAKE_PRIVATE, nToWake, NULL, NULL);
 +}
 +
 +void notifyAll(const void* uaddr) {
-+    _umtx_op(const_cast<void*>(uaddr), UMTX_OP_WAKE, INT_MAX, NULL, NULL);
++    _umtx_op(const_cast<void*>(uaddr), UMTX_OP_WAKE_PRIVATE, INT_MAX, NULL, NULL);
 +}
 +
 +bool waitUntil(const void* uaddr,
 +               uint32_t old,
 +               boost::optional<system_clock::time_point> deadline) {
-+    struct timespec timeout;
-+    bool timeoutOverflow = false;
++    struct _umtx_time umtx_deadline;
++    void* uaddr2 = nullptr;
++
 +    if (deadline) {
-+        int64_t micros = durationCount<Microseconds>(*deadline - system_clock::now());
-+        if (micros <= 0) {
-+            return false;  // Synthesize a timeout.
-+        }
++        umtx_deadline._timeout.tv_sec = durationCount<Seconds>(deadline->time_since_epoch());
++        umtx_deadline._timeout.tv_nsec = durationCount<Nanoseconds>(
++                deadline->time_since_epoch() - stdx::chrono::seconds(umtx_deadline._timeout.tv_sec));
++        umtx_deadline._flags = UMTX_ABSTIME;
++        umtx_deadline._clockid = CLOCK_REALTIME_FAST;
++        uaddr2 = &umtx_deadline;
++    }
 +
-+        if (micros > int64_t(std::numeric_limits<uint32_t>::max())) {
-+            // 2**32 micros is a little over an hour. If this happens, we wait as long as we can,
-+            // then return as-if a spurious wakeup happened, rather than a timeout. This will cause
-+            // the caller to loop and we will compute a smaller time each pass, eventually reaching
-+            // a representable timeout.
-+            micros = std::numeric_limits<uint32_t>::max();
-+            timeoutOverflow = true;
++    int umtxOpRet;
++    if ((umtxOpRet = _umtx_op(const_cast<void*>(uaddr), UMTX_OP_WAIT_UINT_PRIVATE, old, (void*)sizeof(struct _umtx_time), uaddr2)) != 0) {
++        if (errno == ETIMEDOUT) {
++            return false;
 +        }
-+
-+	timeout.tv_sec = micros / 1000;
-+	timeout.tv_nsec = (micros % 1000) * 1000;
++        invariant(umtxOpRet == 0, errorMessage(lastSystemError()));
 +    }
-+
-+    if (_umtx_op(const_cast<void*>(uaddr), UMTX_OP_WAIT, old, (void*)sizeof(struct timespec), &timeout) != -1)
-         return true;
++    return true;
+ }
 
-     // There isn't a good list of possible errors, so assuming that anything other than a timeout
+ #else