ipv6: drop spurious revert of merged signal/pthread changes

This branch predated the merges of the tgkill/rt_sigtimedwait (osv_sigtimedwait)
and pthread_mutex_timedlock work; its diff vs master had begun to revert them
(and delete tst-signal-fills.cc).  Restore libc/signal.cc, libc/pthread.cc,
linux.cc and tst-signal-fills.cc to master and re-add tst-signal-fills.so to the
test list, so this branch touches only the IPv6 forward-port.

Author: gburd

libc/pthread.cc

@@ -452,19 +452,62 @@ int pthread_mutex_trylock(pthread_mutex_t *m)
     return 0;
 }
 
+// Try to lock @m, spinning-with-backoff until the absolute deadline given by
+// @abs_timeout on clock @clock.  OSv's lockfree mutex has no native timed lock,
+// so we poll try_lock() with a short sleep between attempts.  Returns 0 on
+// success, EINVAL for an invalid @abs_timeout, or ETIMEDOUT if the deadline
+// passes first.
+//
+// Note: this is a poll+backoff, not a native timed acquire.  That is fine for
+// the rare contended timedlock; if it ever needs to be tight, add a timed wait
+// to the lockfree mutex itself.
+static int mutex_timedlock_until(pthread_mutex_t *m, clockid_t clock,
+                                 const struct timespec *abs_timeout)
+{
+    // Validate the timeout up front so an invalid @abs_timeout fails with
+    // EINVAL without acquiring the mutex, as POSIX requires, even on the
+    // uncontended fast path.
+    if (!abs_timeout || abs_timeout->tv_nsec < 0 ||
+        abs_timeout->tv_nsec >= 1000000000) {
+        return EINVAL;
+    }
+    if (from_libc(m)->try_lock()) {
+        return 0;   // uncontended fast path
+    }
+
+    auto deadline_ns = std::chrono::seconds(abs_timeout->tv_sec) +
+                       std::chrono::nanoseconds(abs_timeout->tv_nsec);
+    auto now = [clock]() -> std::chrono::nanoseconds {
+        if (clock == CLOCK_MONOTONIC) {
+            return osv::clock::uptime::now().time_since_epoch();
+        }
+        return osv::clock::wall::now().time_since_epoch();
+    };
+
+    while (now() < deadline_ns) {
+        if (from_libc(m)->try_lock()) {
+            return 0;
+        }
+        sched::thread::sleep(std::chrono::microseconds(50));
+    }
+    // One last attempt right at the deadline.
+    return from_libc(m)->try_lock() ? 0 : ETIMEDOUT;
+}
+
 int pthread_mutex_timedlock(pthread_mutex_t *m,
         const struct timespec *abs_timeout)
 {
-    WARN_STUBBED();
-    return EINVAL;
+    return mutex_timedlock_until(m, CLOCK_REALTIME, abs_timeout);
 }
 
 int pthread_mutex_clocklock(pthread_mutex_t *m,
                             clockid_t clock,
                             const struct timespec *abs_timeout)
 {
-    WARN_STUBBED();
-    return EINVAL;
+    if (clock != CLOCK_REALTIME && clock != CLOCK_MONOTONIC) {
+        return EINVAL;
+    }
+    return mutex_timedlock_until(m, clock, abs_timeout);
 }
 
 int pthread_mutex_unlock(pthread_mutex_t *m)

libc/signal.cc

@@ -323,6 +323,54 @@ int sigwait(const sigset_t *set, int *sig)
     return 0;
 }
 
+// Timed variant used by rt_sigtimedwait(2).  Waits for one of the signals in
+// @set to be delivered, or for the relative @timeout to elapse.  A {0,0}
+// timeout polls (returns immediately with EAGAIN if nothing matching is
+// pending).  Returns the signal number, or -1 with errno set (EAGAIN on
+// timeout, EINVAL on a malformed timeout).  Called from linux.cc; kept here
+// because it needs the signal-waiter internals.
+extern "C" OSV_LIBC_API
+int osv_sigtimedwait(const sigset_t *set, siginfo_t *si,
+                     const struct timespec *timeout)
+{
+    // Validate the timeout as Linux does: a malformed timespec must fail with
+    // EINVAL rather than arm a bogus (or negative) timer.
+    if (!timeout || timeout->tv_sec < 0 ||
+        timeout->tv_nsec < 0 || timeout->tv_nsec >= 1000000000) {
+        errno = EINVAL;
+        return -1;
+    }
+    sched::timer tmr(*sched::thread::current());
+    tmr.set(osv::clock::uptime::now() +
+            std::chrono::seconds(timeout->tv_sec) +
+            std::chrono::nanoseconds(timeout->tv_nsec));
+
+    // Only accept a delivered signal that is a member of @set (rt_sigtimedwait
+    // waits for a specific set); a signal outside the set is not what the
+    // caller asked for, so keep waiting for it (or the timeout).
+    int signo = 0;
+    sched::thread::wait_until([&] {
+        int pending = thread_pending_signal;
+        if (pending != 0 && (!set || sigismember(set, pending))) {
+            signo = pending;
+            return true;
+        }
+        return tmr.expired();
+    });
+
+    if (signo == 0) {
+        // Timed out (or polled with {0,0}) with no matching signal.
+        errno = EAGAIN;
+        return -1;
+    }
+    thread_pending_signal = 0;
+    if (si) {
+        memset(si, 0, sizeof(*si));
+        si->si_signo = signo;
+    }
+    return signo;
+}
+
 // Partially-Linux-compatible support for kill(2).
 // Note that this is different from our generate_signal() - the latter is only
 // suitable for delivering SIGFPE and SIGSEGV to the same thread that called

linux.cc

@@ -67,6 +67,7 @@
 #include <osv/syscalls_config.h>
 
 extern "C" int eventfd2(unsigned int, int);
+extern "C" int osv_sigtimedwait(const sigset_t *, siginfo_t *, const struct timespec *);
 
 extern "C" OSV_LIBC_API long gettid()
 {
@@ -395,12 +396,15 @@ int rt_sigprocmask(int how, sigset_t * nset, sigset_t * oset, size_t sigsetsize)
 
 int rt_sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec *timeout, size_t sigsetsize)
 {
-    if (!timeout || (!timeout->tv_sec && !timeout->tv_nsec)) {
+    if (!timeout) {
+        // No timeout: block indefinitely for a matching signal.
         return sigwaitinfo(set, info);
-    } else {
-        errno = ENOSYS;
-        return -1;
     }
+    // A timeout of {0,0} is a non-blocking poll (return EAGAIN if nothing is
+    // already pending); a positive timeout blocks up to that long.  Both are
+    // handled by osv_sigtimedwait, which returns immediately when the deadline
+    // is already in the past.
+    return osv_sigtimedwait(set, info, timeout);
 }
 
 #if CONF_syscall_sys_exit
@@ -656,17 +660,39 @@ static int pselect6(int nfds, fd_set *readfds, fd_set *writefds,
 #if CONF_syscall_tgkill
 static int tgkill(int tgid, int tid, int sig)
 {
+    // On Linux tid<=0 and tgid<=0 are malformed arguments -> EINVAL (ESRCH is
+    // reserved for well-formed IDs that simply do not exist).
+    if (tid <= 0 || tgid <= 0) {
+        errno = EINVAL;
+        return -1;
+    }
+    // OSv is a single process, so the only valid thread-group id is our own.
+    if (tgid != getpid()) {
+        errno = ESRCH;
+        return -1;
+    }
+    // The self case is the common one (raise()/abort()); deliver directly.
+    if (tid == gettid()) {
+        return kill(getpid(), sig);
+    }
+    // Targeting another thread: verify the thread exists, then deliver via the
+    // process-wide signal path.  OSv delivers signals process-wide rather than
+    // to one specific thread, so the signal is handled by the process (a waiter
+    // or a fresh handler thread) rather than strictly by `tid`; this is the
+    // same approximation kill() already makes, and is far better than the
+    // previous ENOSYS for a valid live tid.
     //
-    // Given OSv supports sigle process only, we only support this syscall
-    // when thread group id is self (getpid()) or -1 (see https://linux.die.net/man/2/tgkill)
-    // AND tid points to the current thread (caller)
-    // Ideally we would want to delegate to pthread_kill() but there is no
-    // easy way to map tgid to pthread_t so we directly delegate to kill().
-    if ((tgid == -1 || tgid == getpid()) && (tid == gettid())) {
-        return kill(tgid, sig);
+    // Use with_thread_by_id() rather than find_by_id(): it holds the thread
+    // map lock for the duration, so the thread cannot be freed out from under
+    // the existence check (find_by_id returns a pointer with no such guarantee).
+    bool exists = false;
+    sched::with_thread_by_id((unsigned)tid, [&exists] (sched::thread *t) {
+        exists = (t != nullptr);
+    });
+    if (exists) {
+        return kill(getpid(), sig);
     }
-
-    errno = ENOSYS;
+    errno = ESRCH;
     return -1;
 }
 #endif

modules/tests/Makefile

@@ -128,6 +128,7 @@ tests := tst-pthread.so misc-ramdisk.so tst-vblk.so tst-bsd-evh.so \
 	tst-fpu.so tst-preempt.so tst-tracepoint.so tst-hub.so \
 	misc-console.so misc-leak.so misc-readbench.so misc-mmap-anon-perf.so \
 	tst-mmap-file.so misc-mmap-big-file.so tst-mmap.so tst-huge.so \
+	tst-signal-fills.so \
 	tst-prctl.so \
 	tst-mmap-file-cow.so \
 	tst-elf-permissions.so misc-mutex.so misc-sockets.so tst-condvar.so \

tests/tst-signal-fills.cc

@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2026 Greg Burd
+ *
+ * This work is open source software, licensed under the terms of the
+ * BSD license as described in the LICENSE file in the top-level directory.
+ */
+
+// Exercises the relaxed tgkill(2) and the rt_sigtimedwait(2) timeout path.
+// Built and run on the OSv test image.
+
+#include <sys/syscall.h>
+#include <signal.h>
+#include <unistd.h>
+#include <time.h>
+#include <errno.h>
+#include <pthread.h>
+
+#include <cassert>
+#include <atomic>
+#include <iostream>
+
+static std::atomic<int> g_caught{0};
+static void handler(int) { g_caught.fetch_add(1, std::memory_order_relaxed); }
+
+static long gettid_() { return syscall(SYS_gettid); }
+
+int main()
+{
+    std::cerr << "Running signal-fills tests\n";
+
+    // ---- tgkill ----
+    struct sigaction sa {};
+    sa.sa_handler = handler;
+    sigaction(SIGUSR1, &sa, nullptr);
+
+    // tgkill to our own tgid/tid delivers the signal.
+    g_caught = 0;
+    assert(syscall(SYS_tgkill, getpid(), gettid_(), SIGUSR1) == 0);
+    for (int i = 0; i < 100 && g_caught == 0; i++) usleep(1000);
+    assert(g_caught >= 1);
+
+    // tgkill with a wrong tgid -> ESRCH.
+    errno = 0;
+    assert(syscall(SYS_tgkill, getpid() + 12345, gettid_(), SIGUSR1) == -1 && errno == ESRCH);
+
+    // tgkill to a non-existent tid -> ESRCH (not a crash / not silently OK).
+    errno = 0;
+    assert(syscall(SYS_tgkill, getpid(), 0x7fffff, SIGUSR1) == -1 && errno == ESRCH);
+
+    // tgkill targeting another *live* thread is accepted and the signal is
+    // delivered process-wide (OSv's delivery model).
+    pthread_t th;
+    struct thread_args {
+        std::atomic<long> tid{0};
+        std::atomic<bool> stop{false};
+    } targs;
+    // targs lives on this stack frame until pthread_join() below, so the child
+    // can safely reference it; no heap allocation to leak.
+    int rc = pthread_create(&th, nullptr, [](void *p) -> void * {
+        auto *a = static_cast<thread_args *>(p);
+        a->tid.store(syscall(SYS_gettid));
+        while (!a->stop.load()) usleep(1000);
+        return nullptr;
+    }, &targs);
+    assert(rc == 0);
+    while (targs.tid == 0) usleep(1000);
+    g_caught = 0;
+    assert(syscall(SYS_tgkill, getpid(), targs.tid.load(), SIGUSR1) == 0);
+    for (int i = 0; i < 100 && g_caught == 0; i++) usleep(1000);
+    assert(g_caught >= 1);
+    targs.stop = true;
+    pthread_join(th, nullptr);
+
+    // ---- rt_sigtimedwait timeout path ----
+    // Block SIGUSR2, then rt_sigtimedwait with a short timeout and no pending
+    // signal -> times out with EAGAIN (previously returned ENOSYS).
+    sigset_t set;
+    sigemptyset(&set);
+    sigaddset(&set, SIGUSR2);
+    sigprocmask(SIG_BLOCK, &set, nullptr);
+
+    struct timespec ts { 0, 150 * 1000 * 1000 };  // 150 ms
+    siginfo_t si;
+    struct timespec before, after;
+    clock_gettime(CLOCK_MONOTONIC, &before);
+    errno = 0;
+    int r = syscall(SYS_rt_sigtimedwait, &set, &si, &ts, sizeof(sigset_t));
+    clock_gettime(CLOCK_MONOTONIC, &after);
+    assert(r == -1 && errno == EAGAIN);
+    long long ms = (after.tv_sec - before.tv_sec) * 1000 +
+                   (after.tv_nsec - before.tv_nsec) / 1000000;
+    assert(ms >= 130);   // actually waited ~150 ms, did not return ENOSYS instantly
+
+    std::cerr << "signal-fills tests PASSED\n";
+    return 0;
+}