From f6936c48f382a12b7b67fda40352b8e377662743 Mon Sep 17 00:00:00 2001 From: Christopher Faylor Date: Mon, 19 Jan 2004 05:46:54 +0000 Subject: * cygwin/include/signal.h: Add copyright notice. * cygwin.din: Make clock SIGFE. Add clock_gettime, sigwaitinfo, timer_create, timer_delete, timer_settime. * include/cygwin/version.h: Reflect above additions. * fork.cc (fork_child): Call fixup_timers_after_fork. * signal.cc (sigwait): Remove unused variable. * timer.cc: New file. (clock_gettime): Define new function. (timer_tracker): Define new struct used by timer functions. (timer_tracker::timer_tracker): New function. (to_us): New function. (timer_thread): New function. (timer_tracker::settime): New function. (timer_create): New function. (timer_settime): New function. (timer_delete): New function. (fixup_timers_after_fork): New function. * cygthread.cc: Bump thread count. * signal.cc (sigwaitinfo): Define new function. (sigwait): Redefine based on sigwaitinfo. * include/cygwin/signal.h (sigwaitinfo): Declare. (sigwait): Ditto. * dtable.cc (dtable::vfork_parent_restore): Avoid double close of ctty when ctty == ctty_on_hold. * cygtls.h (_threadinfo::threadkill): New element. (_threadinfo::set_threadkill): Declare new function. (_threadinfo::reset_threadkill): Declare new function. * dcrt0.cc (dcrt0_1): Call here so that it will be possible to attach to running process with #(*& Windows Me/9x. (initial_env): Try to initialize strace if uninitialized. * gendef: Don't zero signal if threadkill is set since that will happen in the called function. * signal.cc (sigwait): Ensure cleanup in error conditions. * sigproc.cc (sig_send): Clear packet mask storage. (wait_subproc): Fill in child exit code in siginfo_t structure. * thread.cc (pthread_kill): Set threadkill flag. * tlsoffsets.h: Regenerate. Throughout, use siginfo_t to fill out all signal information for "kernel" signals. * cygtls.h (_threadinfo::set_siginfo): Declare new function. * cygtls.cc (_threadinfo::set_siginfo): Define new function. * dcrt0.cc (do_exit): Accommodate siginfo_t considerations. * exceptions.cc (handle_exceptions): Ditto. (sig_handle_tty_stop): Ditto. (ctrl_c_handler): Use killsys() to send signal. (sigpacket::process): Rename from sig_handle. Use siginfo_t field from sigpacket for everything. (tty_min::kill_pgrp): Accommodate siginfo_t considerations. (fhandler_termios::bg_check): Ditto. * fhandler_tty.cc (fhandler_tty_slave::ioctl): Use killsys() to send signal. * signal.cc (kill_worker): Rewrite to use siginfo_t second argument. (kill_pgrp): Ditto. (kill0): Define new function pulled from kill(). (kill): Rewrite as frontend to kill0. (killsys): Define new function. * sigproc.cc (sigelem): Eliminate. (sigpacket): Move to sigproc.h. Subsume sigelem. (pending_signals): Use sigpacket rather than sigelem for everything. (sig_clear): Ditto. (wait_sig): Ditto. (sig_send): Rewrite to use siginfo_t argument. (sig_send): New function wratpper to sig_send with siginfo_t argument. (wait_subproc): Accommodate siginfo_t considerations. * thread.cc (pthread_kill): Ditto. * sigproc.h (sigpacket): Move here. (sigpacket::process): Declare "new" function. (sig_handle): Eliminate declaration. (sig_send): Declare with new paramaters. (killsys): Declare new function. (kill_pgrp): Declare. * winsup.h: Move some signal-specific stuff to sigproc.h. * include/cygwin/signal.h: Tweak some siginfo_t stuff. --- winsup/cygwin/timer.cc | 275 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 275 insertions(+) create mode 100644 winsup/cygwin/timer.cc (limited to 'winsup/cygwin/timer.cc') diff --git a/winsup/cygwin/timer.cc b/winsup/cygwin/timer.cc new file mode 100644 index 000000000..8e836e9d4 --- /dev/null +++ b/winsup/cygwin/timer.cc @@ -0,0 +1,275 @@ +/* timer.cc + + Copyright 2004 Red Hat, Inc. + +This file is part of Cygwin. + +This software is a copyrighted work licensed under the terms of the +Cygwin license. Please consult the file "CYGWIN_LICENSE" for +details. */ + +#include "winsup.h" +#include +#include +#include "cygerrno.h" +#include "security.h" +#include "hires.h" +#include "thread.h" +#include "cygtls.h" +#include "cygthread.h" +#include "sigproc.h" +#include "sync.h" + +#define TT_MAGIC 0x513e4a1c +struct timer_tracker +{ + static muto *protect; + unsigned magic; + clockid_t clock_id; + sigevent evp; + itimerspec it; + HANDLE cancel; + int flags; + cygthread *th; + struct timer_tracker *next; + int settime (int, const itimerspec *, itimerspec *); + timer_tracker (clockid_t, const sigevent *); + timer_tracker (); +}; + +timer_tracker ttstart; + +muto *timer_tracker::protect; + +timer_tracker::timer_tracker () +{ + new_muto (protect); +} + +timer_tracker::timer_tracker (clockid_t c, const sigevent *e) +{ + if (e != NULL) + evp = *e; + else + { + evp.sigev_notify = SIGEV_SIGNAL; + evp.sigev_signo = SIGALRM; + evp.sigev_value.sival_ptr = this; + } + clock_id = c; + cancel = NULL; + flags = 0; + memset (&it, 0, sizeof (it)); + protect->acquire (); + next = ttstart.next; + ttstart.next = this; + protect->release (); + magic = TT_MAGIC; +} + +static long long +to_us (timespec& ts) +{ + long long res = ts.tv_sec; + res *= 1000000; + res += ts.tv_nsec / 1000 + ((ts.tv_nsec % 1000) >= 500 ? 1 : 0); + return res; +} + +static NO_COPY itimerspec itzero; +static NO_COPY timespec tzero; + +static DWORD WINAPI +timer_thread (VOID *x) +{ + timer_tracker *tp = ((timer_tracker *) x); + timer_tracker tt = *tp; + for (bool first = true; ; first = false) + { + long long sleep_us = to_us (first ? tt.it.it_value : tt.it.it_interval); + long long sleep_to = sleep_us; + long long now = gtod.usecs (false); + if (tt.flags & TIMER_ABSTIME) + sleep_us -= now; + else + sleep_to += now; + + DWORD sleep_ms = (sleep_us < 0) ? 0 : (sleep_us / 1000); + debug_printf ("%p waiting for %u ms, first %d", x, sleep_ms, first); + tp->it.it_value = tzero; + switch (WaitForSingleObject (tt.cancel, sleep_ms)) + { + case WAIT_TIMEOUT: + debug_printf ("timed out"); + break; + case WAIT_OBJECT_0: + now = gtod.usecs (false); + sleep_us = sleep_to - now; + if (sleep_us < 0) + sleep_us = 0; + tp->it.it_value.tv_sec = sleep_us / 1000000; + tp->it.it_value.tv_nsec = (sleep_us % 1000000) * 1000; + debug_printf ("%p cancelled, elapsed %D", x, sleep_us); + goto out; + default: + debug_printf ("%p timer wait failed, %E", x); + goto out; + } + + switch (tt.evp.sigev_notify) + { + case SIGEV_SIGNAL: + { + siginfo_t si; + memset (&si, 0, sizeof (si)); + si.si_signo = tt.evp.sigev_signo; + si.si_sigval.sival_ptr = tt.evp.sigev_value.sival_ptr; + debug_printf ("%p sending sig %d", x, tt.evp.sigev_signo); + sig_send (NULL, si); + break; + } + case SIGEV_THREAD: + { + pthread_t notify_thread; + debug_printf ("%p starting thread", x); + int rc = pthread_create (¬ify_thread, tt.evp.sigev_notify_attributes, + (void * (*) (void *)) tt.evp.sigev_notify_function, + &tt.evp.sigev_value); + if (rc) + { + debug_printf ("thread creation failed, %E"); + return 0; + } + // FIXME: pthread_join? + break; + } + } + if (!tt.it.it_interval.tv_sec && !tt.it.it_interval.tv_nsec) + break; + tt.flags = 0; + debug_printf ("looping"); + } + +out: + CloseHandle (tt.cancel); + // FIXME: race here but is it inevitable? + if (tt.cancel == tp->cancel) + tp->cancel = NULL; + return 0; +} + +static bool +it_bad (const timespec& t) +{ + if (t.tv_nsec < 0 || t.tv_nsec >= 1000000000 || t.tv_sec < 0) + { + set_errno (EINVAL); + return true; + } + return false; +} + +int +timer_tracker::settime (int in_flags, const itimerspec *value, itimerspec *ovalue) +{ + if (!value) + { + set_errno (EINVAL); + return -1; + } + + if (__check_invalid_read_ptr_errno (value, sizeof (*value))) + return -1; + + if (ovalue && check_null_invalid_struct_errno (ovalue)) + return -1; + + itimerspec *elapsed; + if (!cancel) + elapsed = &itzero; + else + { + SetEvent (cancel); // should be closed when the thread exits + th->detach (); + elapsed = ⁢ + } + + if (ovalue) + *ovalue = *elapsed; + + if (value->it_value.tv_sec || value->it_value.tv_nsec) + { + if (it_bad (value->it_value)) + return -1; + if (it_bad (value->it_interval)) + return -1; + flags = in_flags; + cancel = CreateEvent (&sec_none_nih, TRUE, FALSE, NULL); + it = *value; + th = new cygthread (timer_thread, this, "itimer"); + } + + return 0; +} + +extern "C" int +timer_create (clockid_t clock_id, struct sigevent *evp, timer_t *timerid) +{ + if (evp && check_null_invalid_struct_errno (evp)) + return -1; + if (check_null_invalid_struct_errno (timerid)) + return -1; + + if (clock_id != CLOCK_REALTIME) + { + set_errno (EINVAL); + return -1; + } + + *timerid = (timer_t) new timer_tracker (clock_id, evp); + return 0; +} + +extern "C" int +timer_settime (timer_t timerid, int flags, const struct itimerspec *value, + struct itimerspec *ovalue) +{ + timer_tracker *tt = (timer_tracker *) timerid; + if (check_null_invalid_struct_errno (tt) || tt->magic != TT_MAGIC) + return -1; + return tt->settime (flags, value, ovalue); +} + +extern "C" int +timer_delete (timer_t timerid) +{ + timer_tracker *in_tt = (timer_tracker *) timerid; + if (check_null_invalid_struct_errno (in_tt) || in_tt->magic != TT_MAGIC) + return -1; + + timer_tracker::protect->acquire (); + for (timer_tracker *tt = &ttstart; tt->next != NULL; tt = tt->next) + if (tt->next == in_tt) + { + timer_tracker *deleteme = tt->next; + tt->next = deleteme->next; + delete deleteme; + timer_tracker::protect->release (); + return 0; + } + timer_tracker::protect->release (); + + set_errno (EINVAL); + return 0; +} + +void +fixup_timers_after_fork () +{ + for (timer_tracker *tt = &ttstart; tt->next != NULL; /* nothing */) + { + timer_tracker *deleteme = tt->next; + tt->next = deleteme->next; + delete deleteme; + } +} -- cgit v1.2.3