/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│ │ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │ ╞══════════════════════════════════════════════════════════════════════════════╡ │ Copyright 2020 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/assert.h" #include "libc/calls/internal.h" #include "libc/calls/sig.internal.h" #include "libc/calls/struct/sigset.h" #include "libc/calls/struct/timespec.internal.h" #include "libc/calls/syscall_support-nt.internal.h" #include "libc/errno.h" #include "libc/intrin/atomic.h" #include "libc/intrin/weaken.h" #include "libc/nt/enum/wait.h" #include "libc/nt/errors.h" #include "libc/nt/events.h" #include "libc/nt/runtime.h" #include "libc/nt/struct/overlapped.h" #include "libc/nt/struct/pollfd.h" #include "libc/nt/synchronization.h" #include "libc/nt/thread.h" #include "libc/nt/winsock.h" #include "libc/sock/internal.h" #include "libc/sysv/consts/poll.h" #include "libc/sysv/consts/sicode.h" #include "libc/sysv/errfuns.h" #include "libc/thread/posixthread.internal.h" #ifdef __x86_64__ textwindows ssize_t __winsock_block(int64_t handle, uint32_t flags, bool nonblock, uint32_t srwtimeout, sigset_t waitmask, int StartSocketOp(int64_t handle, struct NtOverlapped *overlap, uint32_t *flags, void *arg), void *arg) { // convert relative to absolute timeout struct timespec deadline; if (srwtimeout) { deadline = timespec_add(sys_clock_gettime_monotonic_nt(), timespec_frommillis(srwtimeout)); } else { deadline = timespec_max; } for (;;) { int got_sig = 0; bool got_cancel = false; bool got_eagain = false; uint32_t other_error = 0; // create event handle for overlapped i/o intptr_t event; if (!(event = WSACreateEvent())) return __winsockerr(); struct NtOverlapped overlap = {.hEvent = event}; bool32 ok = !StartSocketOp(handle, &overlap, &flags, arg); if (!ok && WSAGetLastError() == kNtErrorIoPending) { if (nonblock) { // send() and sendto() shall not pass O_NONBLOCK along to here // because winsock has a bug that causes CancelIoEx() to cause // WSAGetOverlappedResult() to report errors when it succeeded CancelIoEx(handle, &overlap); got_eagain = true; } else { // atomic block on i/o completion, signal, or cancel // it's not safe to acknowledge cancelation from here // it's not safe to call any signal handlers from here intptr_t sev; if ((sev = CreateEvent(0, 0, 0, 0))) { // installing semaphore before sig get makes wait atomic struct PosixThread *pt = _pthread_self(); pt->pt_event = sev; pt->pt_blkmask = waitmask; atomic_store_explicit(&pt->pt_blocker, PT_BLOCKER_EVENT, memory_order_release); if (_is_canceled()) { got_cancel = true; CancelIoEx(handle, &overlap); } else if (_weaken(__sig_get) && (got_sig = _weaken(__sig_get)(waitmask))) { CancelIoEx(handle, &overlap); } else { struct timespec now = sys_clock_gettime_monotonic_nt(); struct timespec remain = timespec_subz(deadline, now); int64_t millis = timespec_tomillis(remain); uint32_t waitms = MIN(millis, 0xffffffffu); intptr_t hands[] = {event, sev}; uint32_t wi = WSAWaitForMultipleEvents(2, hands, 0, waitms, 0); if (wi == 1) { // semaphore was signaled by signal enqueue CancelIoEx(handle, &overlap); if (_weaken(__sig_get)) got_sig = _weaken(__sig_get)(waitmask); } else if (wi == kNtWaitTimeout) { CancelIoEx(handle, &overlap); got_eagain = true; } else if (wi == -1u) { other_error = WSAGetLastError(); CancelIoEx(handle, &overlap); } } atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release); CloseHandle(sev); } else { other_error = GetLastError(); CancelIoEx(handle, &overlap); } } ok = true; } uint32_t exchanged = 0; if (ok) ok = WSAGetOverlappedResult(handle, &overlap, &exchanged, true, &flags); uint32_t io_error = WSAGetLastError(); WSACloseEvent(event); // check if i/o completed // this could forseeably happen even if CancelIoEx was called if (ok) { if (got_sig) // swallow dequeued signal _weaken(__sig_relay)(got_sig, SI_KERNEL, waitmask); return exchanged; } // check if i/o failed if (io_error != kNtErrorOperationAborted) { if (got_sig) // swallow dequeued signal _weaken(__sig_relay)(got_sig, SI_KERNEL, waitmask); errno = __dos2errno(io_error); return -1; } // it's now reasonable to report semaphore creation error if (other_error) { unassert(!got_sig); errno = __dos2errno(other_error); return -1; } // check for non-block cancel or timeout if (got_eagain && !got_sig && !got_cancel) return eagain(); // check for thread cancelation and acknowledge if (_check_cancel() == -1) return -1; // if signal module has been linked, then if (_weaken(__sig_get)) { // gobble up all unmasked pending signals // it's now safe to recurse into signal handlers int handler_was_called = 0; do { if (got_sig) handler_was_called |= _weaken(__sig_relay)(got_sig, SI_KERNEL, waitmask); } while ((got_sig = _weaken(__sig_get)(waitmask))); // check if SIGTHR handler was called if (_check_cancel() == -1) return -1; // check if signal handler without SA_RESTART was called if (handler_was_called & SIG_HANDLED_NO_RESTART) return eintr(); // emulates linux behavior of having timeouts @norestart if (handler_was_called & SIG_HANDLED_SA_RESTART) if (srwtimeout) return eintr(); } // otherwise try the i/o operation again } } #endif /* __x86_64__ */