Implement nacl_irt_futex for non-sfi mode.

components/nacl/loader/nonsfi/irt_futex.cc

Index: components/nacl/loader/nonsfi/irt_futex.cc
diff --git a/components/nacl/loader/nonsfi/irt_futex.cc b/components/nacl/loader/nonsfi/irt_futex.cc
new file mode 100644
index 0000000000000000000000000000000000000000..fb1baa4bf65ac8e4a233a22f21b9f94deddb7819
--- /dev/null
+++ b/components/nacl/loader/nonsfi/irt_futex.cc
@@ -0,0 +1,81 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <errno.h>
+#include <linux/futex.h>
+#include <sys/syscall.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#include "components/nacl/loader/nonsfi/irt_interfaces.h"
+#include "native_client/src/trusted/service_runtime/include/sys/time.h"
+
+namespace nacl {
+namespace nonsfi {
+namespace {
+
+// Converts a pair of nacl's timespec of absolute time and host's timespec of

[Mark Seaborn, 2014/01/15 19:27:54]

Nit: capitalise as "NaCl"

[hidehiko, 2014/01/16 06:52:23]

Done.

+// the current time to host's timespec of the relative time between them.
+// Returns true if the relative time is non-negative. Otherwise false (and

[Mark Seaborn, 2014/01/15 19:27:54]

Maybe just have the caller check whether the resulting tv_sec is non-negative? 
nacl_abi_time_t is defined as signed -- you can comment that you're assuming
that if you want.

[hidehiko, 2014/01/16 06:52:23]

Done.

+// reltime is not available in this case).
+bool NaClAbsTimeToRelTime(const struct nacl_abi_timespec& nacl_abstime,
+                          const struct timespec& now,
+                          struct timespec* reltime) {
+  const int64 kNanoSecondsPerSecond = 1000000000;

[Mark Seaborn, 2014/01/15 19:27:54]

Maybe use "int64_t" rather than "int64"?  In Linux code, we can use the former
and it's more standard.  However, kNanoSecondsPerSecond can just be int
anyway...

[hidehiko, 2014/01/16 06:52:23]

Acknowledged.

+  int64 elapsed_nsec =

[Mark Seaborn, 2014/01/15 19:27:54]

It's better to do what unsandboxed_irt.c does:

    reltime.tv_sec = abstime->tv_sec - time_now.tv_sec;
    reltime.tv_nsec = abstime->tv_nsec - time_now.tv_nsec;
    if (reltime.tv_nsec < 0) {
      reltime.tv_sec -= 1;
      reltime.tv_nsec += 1000000000;
    }

This doesn't involve multiplication and division, so it's more efficient.

[hidehiko, 2014/01/16 06:52:23]

Done, assuming both input tv_nsec are non-negative.
BTW, just curious, the cost of "if + decrement + add" is cheaper than
"multiplication + division" in most cases? (I believe you, but I'd also like to
know the source so that I can make a criterion in my mind for future CLs :-).

[Mark Seaborn, 2014/01/16 19:39:47]

Right.  It's required that 0 <= tv_nsec < 1000000000.  Linux's futex syscall
returns EINVAL otherwise.  We should probably document this in irt.h.

I suppose it would be worthwhile checking for that condition here too, before
the calculation.  Want to add a check?

I haven't checked whether/where this constraint is specified in the pthread
standard.  Might be worth checking...
Yes, multiplication tends to use a lot more cycles, and division is even more
complex.  On x86-32 and ARM, 64-bit div/mod involve calling out to external
functions.

e.g. See the code for __moddi3 in "objdump -dr /usr/lib32/libgcc_s.so.1".

Checking for 10^9 and doing the carry is the common pattern in glibc.  For
example, see
https://sourceware.org/git/?p=glibc.git;a=blob;f=nptl/pthread_mutex_timedlock....

+      (nacl_abstime.tv_sec - now.tv_sec) * kNanoSecondsPerSecond +
+      (nacl_abstime.tv_nsec - now.tv_nsec);
+  if (elapsed_nsec < 0)
+    return false;
+
+  reltime->tv_sec = elapsed_nsec / kNanoSecondsPerSecond;
+  reltime->tv_nsec = elapsed_nsec % kNanoSecondsPerSecond;
+  return true;
+}
+
+int IrtFutexWaitAbs(volatile int* addr, int value,
+                    const struct nacl_abi_timespec* abstime) {
+  struct timespec timeout;
+  struct timespec* timeout_ptr = NULL;
+  if (abstime) {
+    // futex syscall takes relative timeout, but the ABI for irt's

[Mark Seaborn, 2014/01/15 19:27:54]

Nit: capitalise as "IRT"

[hidehiko, 2014/01/16 06:52:23]

Done.

+    // futex_wait_abs is absolute timeout. So, here we convert it.
+    struct timespec now;
+    if (clock_gettime(CLOCK_REALTIME, &now))
+      return errno;
+
+    // Linux's FUTEX_WAIT returns EINVAL for negative timeout, but it valid

[Mark Seaborn, 2014/01/15 19:27:54]

How about: "but an absolute time that is in the past is a valid argument to
irt_futex_wait_abs()"

[hidehiko, 2014/01/16 06:52:23]

Done.

+    // on irt_futex_wait_abs, and a caller expects ETIMEOUT.

[Mark Seaborn, 2014/01/15 19:27:54]

ETIMEDOUT

[hidehiko, 2014/01/16 06:52:23]

Done.

+    if (!NaClAbsTimeToRelTime(*abstime, now, &timeout))
+      return ETIMEDOUT;
+    timeout_ptr = &timeout;
+  }
+  if (syscall(SYS_futex, addr, FUTEX_WAIT_PRIVATE, value, timeout_ptr, 0, 0))
+    return errno;
+
+  return 0;
+}
+
+int IrtFutexWake(volatile int* addr, int nwake, int* count) {
+  int result = syscall(SYS_futex, addr, FUTEX_WAKE_PRIVATE, nwake, 0, 0, 0);
+  if (result < 0)
+    return errno;
+
+  *count = result;
+  return 0;
+}
+
+}  // namespace
+
+// For futex_wait_abs, the argument type should be nacl_abi_timespec. However,
+// the definition uses its host type, struct timespec. So, here we need to cast
+// it.
+const nacl_irt_futex kIrtFutex = {
+  reinterpret_cast<int(*)(volatile int*, int, const struct timespec*)>(
+      IrtFutexWaitAbs),
+  IrtFutexWake,
+};
+
+}  // namespace nonsfi
+}  // namespace nacl