/*-*- 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 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/calls/internal.h" #include "libc/calls/sig.internal.h" #include "libc/calls/struct/sigset.h" #include "libc/calls/struct/sigset.internal.h" #include "libc/intrin/dll.h" #include "libc/intrin/strace.internal.h" #include "libc/nt/enum/wait.h" #include "libc/nt/events.h" #include "libc/nt/runtime.h" #include "libc/nt/synchronization.h" #include "libc/proc/proc.internal.h" #include "libc/sysv/consts/sicode.h" #include "libc/sysv/consts/sig.h" #include "libc/sysv/consts/w.h" #include "libc/sysv/errfuns.h" #ifdef __x86_64__ static textwindows int __proc_reap(struct Proc *pr, int *wstatus, struct rusage *opt_out_rusage) { if (wstatus) { *wstatus = pr->wstatus; } if (opt_out_rusage) { *opt_out_rusage = pr->ru; } dll_remove(&__proc.zombies, &pr->elem); if (dll_is_empty(__proc.zombies)) { ResetEvent(__proc.haszombies); } if (pr->waiters) { pr->status = PROC_UNDEAD; dll_make_first(&__proc.undead, &pr->elem); } else { dll_make_first(&__proc.free, &pr->elem); CloseHandle(pr->handle); } return pr->pid; } static textwindows int __proc_check(int pid, int *wstatus, struct rusage *opt_out_rusage) { struct Dll *e; for (e = dll_first(__proc.zombies); e; e = dll_next(__proc.zombies, e)) { struct Proc *pr = PROC_CONTAINER(e); if (pid == -1 || pid == pr->pid) { return __proc_reap(pr, wstatus, opt_out_rusage); } } return 0; } static textwindows int __proc_wait(int pid, int *wstatus, int options, struct rusage *rusage, sigset_t waitmask) { for (;;) { // check for signals and cancelation int rc, sig, handler_was_called; if (_check_cancel() == -1) { return -1; } if ((sig = __sig_get(waitmask))) { handler_was_called = __sig_relay(sig, SI_KERNEL, waitmask); if (_check_cancel() == -1) { return -1; // ECANCELED because SIGTHR was just handled } if (handler_was_called & SIG_HANDLED_NO_RESTART) { return eintr(); // a non-SA_RESTART handler was called } } // check for zombie to harvest __proc_lock(); CheckForZombies: rc = __proc_check(pid, wstatus, rusage); if (rc || (options & WNOHANG)) { __proc_unlock(); return rc; } // there's no zombies left // check if there's any living processes if (dll_is_empty(__proc.list)) { __proc_unlock(); return echild(); } // get appropriate wait object // register ourself as waiting struct Proc *pr = 0; uintptr_t hWaitObject; if (pid == -1) { // wait for any status change hWaitObject = __proc.haszombies; ++__proc.waiters; } else { // wait on specific child for (struct Dll *e = dll_first(__proc.list); e; e = dll_next(__proc.list, e)) { pr = PROC_CONTAINER(e); if (pid == pr->pid) break; } if (pr) { // by making the waiter count non-zero, the proc daemon stops // being obligated to monitor this process. this means we may // need to assume responsibility later on for zombifying this ++pr->waiters; hWaitObject = pr->handle; } else { __proc_unlock(); return echild(); } } __proc_unlock(); // perform blocking operation uint32_t wi; uintptr_t sem; struct PosixThread *pt = _pthread_self(); pt->pt_blkmask = waitmask; pt->pt_semaphore = sem = CreateSemaphore(0, 0, 1, 0); atomic_store_explicit(&pt->pt_blocker, PT_BLOCKER_SEM, memory_order_release); wi = WaitForMultipleObjects(2, (intptr_t[2]){hWaitObject, sem}, 0, -1u); atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release); CloseHandle(sem); // log warning if handle unexpectedly closed if (wi & kNtWaitAbandoned) { wi &= ~kNtWaitAbandoned; STRACE("wait4 abandoned %u", wi); } // check for wait() style wakeup __proc_lock(); if (!wi && !pr) { --__proc.waiters; goto CheckForZombies; } // check if killed or win32 error if (wi) { if (pr && --pr->waiters && pr->status == PROC_UNDEAD) { __proc_free(pr); } __proc_unlock(); if (wi == 1) { // __sig_cancel() woke our semaphore continue; } else { // neither posix or win32 define i/o error conditions for // generic wait. failure should only be due to api misuse return einval(); } } // handle process exit notification --pr->waiters; if (pr->status == PROC_ALIVE) { __proc_harvest(pr, true); } switch (pr->status) { case PROC_ALIVE: // exit caused by execve() reparenting __proc_unlock(); break; case PROC_ZOMBIE: // exit happened and we're the first to know rc = __proc_reap(pr, wstatus, rusage); __proc_unlock(); return rc; case PROC_UNDEAD: // exit happened but another thread waited first if (!pr->waiters) { __proc_free(pr); } __proc_unlock(); return echild(); default: __builtin_unreachable(); } } } textwindows int sys_wait4_nt(int pid, int *opt_out_wstatus, int options, struct rusage *opt_out_rusage) { // no support for WCONTINUED and WUNTRACED yet if (options & ~WNOHANG) return einval(); // XXX: NT doesn't really have process groups. For instance the // CreateProcess() flag for starting a process group actually // just does an "ignore ctrl-c" internally. if (pid == 0) pid = -1; if (pid < -1) pid = -pid; sigset_t m = __sig_block(); int rc = __proc_wait(pid, opt_out_wstatus, options, opt_out_rusage, m | 1ull << (SIGCHLD - 1)); __sig_unblock(m); return rc; } #endif /* __x86_64__ */