Implement thread cancellation for aarch64

libc/sysv/sysv.c

@@ -0,0 +1,157 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/syscall-sysv.internal.h"
+#include "libc/dce.h"
+#include "libc/errno.h"
+#include "libc/intrin/atomic.h"
+#include "libc/intrin/weaken.h"
+#include "libc/thread/posixthread.internal.h"
+#include "libc/thread/tls.h"
+#ifndef __x86_64__
+
+// todo(jart): dismal llvm
+register long x0 asm("x0");
+register long x1 asm("x1");
+register long x2 asm("x2");
+register long x3 asm("x3");
+register long x4 asm("x4");
+register long x5 asm("x5");
+register long sysv_ordinal asm("x8");
+register long xnu_ordinal asm("x16");
+register long cosmo_tls_register asm("x28");
+
+void report_cancellation_point(void);
+
+dontinline long systemfive_cancel(void) {
+  return _pthread_cancel_sys();
+}
+
+// special region of executable memory where cancellation is safe
+dontinline long systemfive_cancellable(void) {
+
+  // check (1) this is a cancellation point
+  // plus (2) cancellations aren't disabled
+  struct PosixThread *pth = 0;
+  struct CosmoTib *tib = __get_tls();
+  if (cosmo_tls_register &&               //
+      _weaken(_pthread_cancel_sys) &&     //
+      !(tib->tib_flags & PT_NOCANCEL) &&  //
+      (pth = (struct PosixThread *)tib->tib_pthread)) {
+    // check if cancellation is already pending
+    if (atomic_load_explicit(&pth->cancelled, memory_order_acquire)) {
+      return systemfive_cancel();
+    }
+#if IsModeDbg()
+    if (!(tib->tib_flags & PT_INCANCEL)) {
+      if (_weaken(report_cancellation_point)) {
+        _weaken(report_cancellation_point)();
+      }
+      __builtin_trap();
+    }
+#endif
+  }
+
+  // invoke cancellable system call
+  // this works for both linux and bsd
+  asm volatile("mov\tx9,0\n\t"      // clear carry flag
+               "adds\tx9,x9,0\n\t"  // clear carry flag
+               "svc\t0\n"
+               "systemfive_cancellable_end:\n\t"
+               ".globl\tsystemfive_cancellable_end\n\t"
+               "bcs\t1f\n\t"
+               "b\t2f\n1:\t"
+               "neg\tx0,x0\n2:"
+               : /* global output */
+               : /* global inputs */
+               : "x9", "memory");
+
+  // if it succeeded then we're done
+  if (x0 < -4095ul) {
+    return x0;
+  }
+
+  // check if i/o call was interrupted by sigthr
+  if (pth && x0 == -EINTR &&
+      atomic_load_explicit(&pth->cancelled, memory_order_acquire)) {
+    return systemfive_cancel();
+  }
+
+  // otherwise go down error path
+  return _sysret(x0);
+}
+
+/**
+ * System Five System Call Support.
+ *
+ * This supports POSIX thread cancellation only when the caller flips a
+ * bit in TLS storage that indicates we're inside a cancellation point.
+ *
+ * @param x0 is first argument
+ * @param x1 is second argument
+ * @param x2 is third argument
+ * @param x3 is fourth argument
+ * @param x4 is fifth argument
+ * @param x5 is sixth argument
+ * @param sysv_ordinal is linux ordinal
+ * @param xnu_ordinal is xnu ordinal
+ * @return x0
+ */
+long systemfive(void) {
+
+  // handle special cases
+  if (IsLinux()) {
+    if (sysv_ordinal == 0xfff) {
+      return _sysret(-ENOSYS);
+    }
+    if (sysv_ordinal & 0x800) {
+      sysv_ordinal &= ~0x800;
+      return systemfive_cancellable();
+    }
+  }
+  if (IsXnu()) {
+    if (xnu_ordinal == 0xfff) {
+      return _sysret(-ENOSYS);
+    }
+    if (xnu_ordinal & 0x800) {
+      xnu_ordinal &= ~0x800;
+      return systemfive_cancellable();
+    }
+  }
+
+  // invoke non-blocking system call
+  // this works for both linux and bsd
+  asm volatile("mov\tx9,0\n\t"      // clear carry flag
+               "adds\tx9,x9,0\n\t"  // clear carry flag
+               "svc\t0\n\t"
+               "bcs\t1f\n\t"
+               "b\t2f\n1:\t"
+               "neg\tx0,x0\n2:"
+               : /* global output */
+               : /* global inputs */
+               : "x9", "memory");
+
+  // check result
+  if (x0 < -4095ul) {
+    return x0;
+  } else {
+    return _sysret(x0);
+  }
+}
+
+#endif /* __x86_64__ */