return (*set & (1U << signo)) != 0;
}
+pid_t
+getpgrp (void)
+{
+ return getpid ();
+}
+
+pid_t
+tcgetpgrp (int fd)
+{
+ return getpid ();
+}
+
int
-setpgrp (int pid, int gid)
+setpgid (pid_t pid, pid_t pgid)
{
return 0;
}
+pid_t
+setsid (void)
+{
+ return getpid ();
+}
+
/* Emulations of interval timers.
Limitations: only ITIMER_REAL and ITIMER_PROF are supported.
expires, after stopping the thread which installed the timer. */
struct itimer_data {
- ULONGLONG expire;
- ULONGLONG reload;
- int terminate;
+ volatile ULONGLONG expire;
+ volatile ULONGLONG reload;
+ volatile int terminate;
int type;
HANDLE caller_thread;
HANDLE timer_thread;
static CRITICAL_SECTION crit_real, crit_prof;
-/* GetThreadTimes is not available on Windows 9X and posibly also on 2K. */
+/* GetThreadTimes is not available on Windows 9X and possibly also on 2K. */
typedef BOOL (WINAPI *GetThreadTimes_Proc) (
HANDLE hThread,
LPFILETIME lpCreationTime,
static GetThreadTimes_Proc s_pfn_Get_Thread_Times;
+#define MAX_SINGLE_SLEEP 30
+#define TIMER_TICKS_PER_SEC 1000
+
/* Return a suitable time value, in 1-ms units, for THREAD, a handle
to a thread. If THREAD is NULL or an invalid handle, return the
current wall-clock time since January 1, 1601 (UTC). Otherwise,
{
ULONGLONG retval;
int use_system_time = 1;
+ /* The functions below return times in 100-ns units. */
+ const int tscale = 10 * TIMER_TICKS_PER_SEC;
if (thread && thread != INVALID_HANDLE_VALUE
&& s_pfn_Get_Thread_Times != NULL)
temp_user.LowPart = user_ftime.dwLowDateTime;
temp_user.HighPart = user_ftime.dwHighDateTime;
retval =
- temp_creation.QuadPart / 10000 + temp_kernel.QuadPart / 10000
- + temp_user.QuadPart / 10000;
+ temp_creation.QuadPart / tscale + temp_kernel.QuadPart / tscale
+ + temp_user.QuadPart / tscale;
}
else
DebPrint (("GetThreadTimes failed with error code %lu\n",
temp.LowPart = current_ftime.dwLowDateTime;
temp.HighPart = current_ftime.dwHighDateTime;
- retval = temp.QuadPart / 10000;
+ retval = temp.QuadPart / tscale;
}
return retval;
}
-#define MAX_SINGLE_SLEEP 30
-
/* Thread function for a timer thread. */
static DWORD WINAPI
timer_loop (LPVOID arg)
int which = itimer->type;
int sig = (which == ITIMER_REAL) ? SIGALRM : SIGPROF;
CRITICAL_SECTION *crit = (which == ITIMER_REAL) ? &crit_real : &crit_prof;
- const DWORD max_sleep = MAX_SINGLE_SLEEP * 1000 / CLOCKS_PER_SEC;
- int new_count = 0;
+ const DWORD max_sleep = MAX_SINGLE_SLEEP * 1000 / TIMER_TICKS_PER_SEC;
HANDLE hth = (which == ITIMER_REAL) ? NULL : itimer->caller_thread;
while (1)
return 0;
if (sleep_time > 0)
{
- Sleep (sleep_time * 1000 / CLOCKS_PER_SEC);
+ Sleep (sleep_time * 1000 / TIMER_TICKS_PER_SEC);
/* Always sleep past the expiration time, to make sure we
never call the handler _before_ the expiration time,
always slightly after it. Sleep(5) makes sure we don't
/* Simulate a signal delivered to the thread which installed
the timer, by suspending that thread while the handler
runs. */
- DWORD result = SuspendThread (itimer->caller_thread);
+ HANDLE th = itimer->caller_thread;
+ DWORD result = SuspendThread (th);
if (result == (DWORD)-1)
return 2;
handler (sig);
- ResumeThread (itimer->caller_thread);
+ ResumeThread (th);
}
/* Update expiration time and loop. */
void
init_timers (void)
{
- /* GetThreadTimes is not avaiulable on all versions of Windows, so
+ /* GetThreadTimes is not available on all versions of Windows, so
need to probe for its availability dynamically, and call it
through a pointer. */
s_pfn_Get_Thread_Times = NULL; /* in case dumped Emacs comes with a value */
start_timer_thread (int which)
{
DWORD exit_code;
+ HANDLE th;
struct itimer_data *itimer =
(which == ITIMER_REAL) ? &real_itimer : &prof_itimer;
&& exit_code == STILL_ACTIVE)
return 0;
+ /* Clean up after possibly exited thread. */
+ if (itimer->timer_thread)
+ {
+ CloseHandle (itimer->timer_thread);
+ itimer->timer_thread = NULL;
+ }
+ if (itimer->caller_thread)
+ {
+ CloseHandle (itimer->caller_thread);
+ itimer->caller_thread = NULL;
+ }
+
/* Start a new thread. */
+ if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
+ GetCurrentProcess (), &th, 0, FALSE,
+ DUPLICATE_SAME_ACCESS))
+ {
+ errno = ESRCH;
+ return -1;
+ }
itimer->terminate = 0;
itimer->type = which;
+ itimer->caller_thread = th;
/* Request that no more than 64KB of stack be reserved for this
thread, to avoid reserving too much memory, which would get in
the way of threads we start to wait for subprocesses. See also
/* This is needed to make sure that the timer thread running for
profiling gets CPU as soon as the Sleep call terminates. */
if (which == ITIMER_PROF)
- SetThreadPriority (itimer->caller_thread, THREAD_PRIORITY_TIME_CRITICAL);
+ SetThreadPriority (itimer->timer_thread, THREAD_PRIORITY_TIME_CRITICAL);
return 0;
}
itimer = (which == ITIMER_REAL) ? &real_itimer : &prof_itimer;
- if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
- GetCurrentProcess (), &itimer->caller_thread, 0,
- FALSE, DUPLICATE_SAME_ACCESS))
- {
- errno = ESRCH;
- return -1;
- }
-
ticks_now = w32_get_timer_time ((which == ITIMER_REAL)
? NULL
- : itimer->caller_thread);
+ : GetCurrentThread ());
t_expire = &itimer->expire;
t_reload = &itimer->reload;
if (expire)
expire -= ticks_now;
- value->it_value.tv_sec = expire / CLOCKS_PER_SEC;
- usecs = (expire % CLOCKS_PER_SEC) * (__int64)1000000 / CLOCKS_PER_SEC;
+ value->it_value.tv_sec = expire / TIMER_TICKS_PER_SEC;
+ usecs =
+ (expire % TIMER_TICKS_PER_SEC) * (__int64)1000000 / TIMER_TICKS_PER_SEC;
value->it_value.tv_usec = usecs;
- value->it_interval.tv_sec = reload / CLOCKS_PER_SEC;
- usecs = (reload % CLOCKS_PER_SEC) * (__int64)1000000 / CLOCKS_PER_SEC;
+ value->it_interval.tv_sec = reload / TIMER_TICKS_PER_SEC;
+ usecs =
+ (reload % TIMER_TICKS_PER_SEC) * (__int64)1000000 / TIMER_TICKS_PER_SEC;
value->it_interval.tv_usec= usecs;
return 0;
return 0;
}
- reload = value->it_interval.tv_sec * CLOCKS_PER_SEC;
+ reload = value->it_interval.tv_sec * TIMER_TICKS_PER_SEC;
usecs = value->it_interval.tv_usec;
if (value->it_interval.tv_sec == 0
- && usecs && usecs * CLOCKS_PER_SEC < clocks_min * 1000000)
+ && usecs && usecs * TIMER_TICKS_PER_SEC < clocks_min * 1000000)
reload = clocks_min;
else
{
- usecs *= CLOCKS_PER_SEC;
+ usecs *= TIMER_TICKS_PER_SEC;
reload += usecs / 1000000;
}
- expire = value->it_value.tv_sec * CLOCKS_PER_SEC;
+ expire = value->it_value.tv_sec * TIMER_TICKS_PER_SEC;
usecs = value->it_value.tv_usec;
if (value->it_value.tv_sec == 0
- && usecs * CLOCKS_PER_SEC < clocks_min * 1000000)
+ && usecs * TIMER_TICKS_PER_SEC < clocks_min * 1000000)
expire = clocks_min;
else
{
- usecs *= CLOCKS_PER_SEC;
+ usecs *= TIMER_TICKS_PER_SEC;
expire += usecs / 1000000;
}
/* Child process management list. */
int child_proc_count = 0;
child_process child_procs[ MAX_CHILDREN ];
-child_process *dead_child = NULL;
static DWORD WINAPI reader_thread (void *arg);
if (cp->pid < 0)
cp->pid = -cp->pid;
- /* pid must fit in a Lisp_Int */
- cp->pid = cp->pid & INTMASK;
-
*pPid = cp->pid;
return TRUE;
delete_child (cp);
}
-/* Wait for any of our existing child processes to die
- When it does, close its handle
- Return the pid and fill in the status if non-NULL. */
+/* Wait for a child process specified by PID, or for any of our
+ existing child processes (if PID is nonpositive) to die. When it
+ does, close its handle. Return the pid of the process that died
+ and fill in STATUS if non-NULL. */
-int
-sys_wait (int *status)
+pid_t
+waitpid (pid_t pid, int *status, int options)
{
DWORD active, retval;
int nh;
- int pid;
child_process *cp, *cps[MAX_CHILDREN];
HANDLE wait_hnd[MAX_CHILDREN];
+ DWORD timeout_ms;
+ int dont_wait = (options & WNOHANG) != 0;
nh = 0;
- if (dead_child != NULL)
+ /* According to Posix:
+
+ PID = -1 means status is requested for any child process.
+
+ PID > 0 means status is requested for a single child process
+ whose pid is PID.
+
+ PID = 0 means status is requested for any child process whose
+ process group ID is equal to that of the calling process. But
+ since Windows has only a limited support for process groups (only
+ for console processes and only for the purposes of passing
+ Ctrl-BREAK signal to them), and since we have no documented way
+ of determining whether a given process belongs to our group, we
+ treat 0 as -1.
+
+ PID < -1 means status is requested for any child process whose
+ process group ID is equal to the absolute value of PID. Again,
+ since we don't support process groups, we treat that as -1. */
+ if (pid > 0)
{
- /* We want to wait for a specific child */
- wait_hnd[nh] = dead_child->procinfo.hProcess;
- cps[nh] = dead_child;
- if (!wait_hnd[nh]) emacs_abort ();
- nh++;
- active = 0;
- goto get_result;
+ int our_child = 0;
+
+ /* We are requested to wait for a specific child. */
+ for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
+ {
+ /* Some child_procs might be sockets; ignore them. Also
+ ignore subprocesses whose output is not yet completely
+ read. */
+ if (CHILD_ACTIVE (cp)
+ && cp->procinfo.hProcess
+ && cp->pid == pid)
+ {
+ our_child = 1;
+ break;
+ }
+ }
+ if (our_child)
+ {
+ if (cp->fd < 0 || (fd_info[cp->fd].flags & FILE_AT_EOF) != 0)
+ {
+ wait_hnd[nh] = cp->procinfo.hProcess;
+ cps[nh] = cp;
+ nh++;
+ }
+ else if (dont_wait)
+ {
+ /* PID specifies our subprocess, but its status is not
+ yet available. */
+ return 0;
+ }
+ }
+ if (nh == 0)
+ {
+ /* No such child process, or nothing to wait for, so fail. */
+ errno = ECHILD;
+ return -1;
+ }
}
else
{
for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
- /* some child_procs might be sockets; ignore them */
- if (CHILD_ACTIVE (cp) && cp->procinfo.hProcess
- && (cp->fd < 0 || (fd_info[cp->fd].flags & FILE_AT_EOF) != 0))
- {
- wait_hnd[nh] = cp->procinfo.hProcess;
- cps[nh] = cp;
- nh++;
- }
+ {
+ if (CHILD_ACTIVE (cp)
+ && cp->procinfo.hProcess
+ && (cp->fd < 0 || (fd_info[cp->fd].flags & FILE_AT_EOF) != 0))
+ {
+ wait_hnd[nh] = cp->procinfo.hProcess;
+ cps[nh] = cp;
+ nh++;
+ }
+ }
+ if (nh == 0)
+ {
+ /* Nothing to wait on, so fail. */
+ errno = ECHILD;
+ return -1;
+ }
}
- if (nh == 0)
- {
- /* Nothing to wait on, so fail */
- errno = ECHILD;
- return -1;
- }
+ if (dont_wait)
+ timeout_ms = 0;
+ else
+ timeout_ms = 1000; /* check for quit about once a second. */
do
{
- /* Check for quit about once a second. */
QUIT;
- active = WaitForMultipleObjects (nh, wait_hnd, FALSE, 1000);
+ active = WaitForMultipleObjects (nh, wait_hnd, FALSE, timeout_ms);
} while (active == WAIT_TIMEOUT);
if (active == WAIT_FAILED)
else
emacs_abort ();
-get_result:
if (!GetExitCodeProcess (wait_hnd[active], &retval))
{
DebPrint (("Wait.GetExitCodeProcess failed with %lu\n",
}
if (retval == STILL_ACTIVE)
{
- /* Should never happen */
+ /* Should never happen. */
DebPrint (("Wait.WaitForMultipleObjects returned an active process\n"));
+ if (pid > 0 && dont_wait)
+ return 0;
errno = EINVAL;
return -1;
}
else
retval <<= 8;
+ if (pid > 0 && active != 0)
+ emacs_abort ();
cp = cps[active];
pid = cp->pid;
#ifdef FULL_DEBUG
numenv++;
}
/* extra env vars... */
- sprintf (ppid_env_var_buffer, "EM_PARENT_PROCESS_ID=%d",
+ sprintf (ppid_env_var_buffer, "EM_PARENT_PROCESS_ID=%lu",
GetCurrentProcessId ());
arglen += strlen (ppid_env_var_buffer) + 1;
numenv++;
DebPrint (("select calling SIGCHLD handler for pid %d\n",
cp->pid));
#endif
- dead_child = cp;
sig_handlers[SIGCHLD] (SIGCHLD);
- dead_child = NULL;
}
}
else if (fdindex[active] == -1)