JehanneOS/newlib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

* wininfo.h (wininfo::timer_active): Delete.

Browse Source 
(wininfo::itv): Ditto.
(wininfo::start_time): Ditto.
(wininfo::window_started): Ditto.
(wininfo::getitimer): Ditto.
(wininfo::setitimer): Ditto.
(wininfo::wininfo): Ditto.
(wininfo::lock): New method.
(wininfo::release): Ditto.
* window.cc: Use new lock/acquire wininfo methods throughout.
(wininfo::wininfo): Delete
(wininfo::getitimer): Ditto.
(wininfo::setitimer): Ditto.
(getitimer): Ditto.
(setitimer): Ditto.
(ualarm): Ditto.
(alarm): Ditto.
(wininfo::lock): Define new function.
(wininfo::release): Ditto.
(wininfo::process): Delete WM_TIMER handling.
* timer.cc (struct timetracker): Delete it, flags.  Add it_interval,
interval_us, sleepto_us, running, init_muto(), syncthread, and gettime().
(ttstart): Make NO_COPY.
(lock_timer_tracker): New class.
(timer_tracker::timer_tracker): Distinguish ttstart case.
(timer_tracker::~timer_tracker): New destructor.  Clean out events, and reset
magic.
(timer_tracker::init_muto): New method.
(to_us): Round up as per POSIX.
(timer_thread): Reorganize to match timer_tracker::settime and
timer_tracker::gettime.  Call sig_send without wait.  Call auto_release.
(timer_tracker::settime): Reorganize logic to avoid race.  Call gettime to
recover old value.
(timer_tracker::gettime): New method.
(timer_create): Properly set errno on invalid timerid.  Use new
lock_timer_tracker method.
(timer_delete): Ditto.  Simplify code slightly.
(timer_gettime): New function.
(fixup_timers_after_fork): Reinit ttstart.
(getitimer): New implementation.
(setitimer): Ditto.
(ualarm): Ditto.
(alarm): Ditto.
* cygwin.din: Export timer_gettime.
* winsup.h: Remove has has_visible_window_station declaration.
* Makefile.in (DLL_OFILES): Add lsearch.o.
* cygthread.h (cygthread::notify_detached): New element.
(cygthread::cygthread): Take optional fourth argument signifying event to
signal on thread completion.
* cygthread.cc (cygthread::stub): Signal notify_detached event, if it exists.
(cygthread::cygthread): Initialize notify_detached from fourth argument.
(cygthread::detach): Wait for notify_detached field is present.
* lsearch.cc: New file.
* search.h: Ditto.
* include/cygwin/version.h: Bump API minor number to 126.
* cygwin.din: Export lsearch, lfind.
This commit is contained in:
Christopher Faylor 2005-03-27 01:57:38 +00:00
parent 9eba97c0d5
commit ec98d19a08
25 changed files with 510 additions and 288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
winsup/cygwin/ChangeLog
View File

@ -1,3 +1,70 @@
2005-03-26 Pierre Humblet <pierre.humblet@ieee.org>
Christopher Faylor <cgf@timesys.com>
* wininfo.h (wininfo::timer_active): Delete.
(wininfo::itv): Ditto.
(wininfo::start_time): Ditto.
(wininfo::window_started): Ditto.
(wininfo::getitimer): Ditto.
(wininfo::setitimer): Ditto.
(wininfo::wininfo): Ditto.
(wininfo::lock): New method.
(wininfo::release): Ditto.
* window.cc: Use new lock/acquire wininfo methods throughout.
(wininfo::wininfo): Delete
(wininfo::getitimer): Ditto.
(wininfo::setitimer): Ditto.
(getitimer): Ditto.
(setitimer): Ditto.
(ualarm): Ditto.
(alarm): Ditto.
(wininfo::lock): Define new function.
(wininfo::release): Ditto.
(wininfo::process): Delete WM_TIMER handling.
* timer.cc (struct timetracker): Delete it, flags. Add it_interval,
interval_us, sleepto_us, running, init_muto(), syncthread, and
gettime().
(ttstart): Make NO_COPY.
(lock_timer_tracker): New class.
(timer_tracker::timer_tracker): Distinguish ttstart case.
(timer_tracker::~timer_tracker): New destructor. Clean out events, and
reset magic.
(timer_tracker::init_muto): New method.
(to_us): Round up as per POSIX.
(timer_thread): Reorganize to match timer_tracker::settime and
timer_tracker::gettime. Call sig_send without wait. Call
auto_release.
(timer_tracker::settime): Reorganize logic to avoid race. Call gettime
to recover old value.
(timer_tracker::gettime): New method.
(timer_create): Properly set errno on invalid timerid. Use new
lock_timer_tracker method.
(timer_delete): Ditto. Simplify code slightly.
(timer_gettime): New function.
(fixup_timers_after_fork): Reinit ttstart.
(getitimer): New implementation.
(setitimer): Ditto.
(ualarm): Ditto.
(alarm): Ditto.
* cygwin.din: Export timer_gettime.
* winsup.h: Remove has has_visible_window_station declaration.
2005-03-26 Christopher Faylor <cgf@timesys.com>
* Makefile.in (DLL_OFILES): Add lsearch.o.
* cygthread.h (cygthread::notify_detached): New element.
(cygthread::cygthread): Take optional fourth argument signifying event
to signal on thread completion.
* cygthread.cc (cygthread::stub): Signal notify_detached event, if it
exists.
(cygthread::cygthread): Initialize notify_detached from fourth argument.
(cygthread::detach): Wait for notify_detached field is present.
* lsearch.cc: New file.
* search.h: Ditto.
* include/cygwin/version.h: Bump API minor number to 126.
* cygwin.din: Export lsearch, lfind.
2005-03-23 Corinna Vinschen <corinna@vinschen.de> 2005-03-23 Corinna Vinschen <corinna@vinschen.de>
* fhandler.h (fhandler_socket::secret_event): Remove. * fhandler.h (fhandler_socket::secret_event): Remove.

6
winsup/cygwin/Makefile.in
View File

@ -117,7 +117,7 @@ MALLOC_OFILES=@MALLOC_OFILES@
DLL_IMPORTS:=$(w32api_lib)/libkernel32.a $(w32api_lib)/libadvapi32.a DLL_IMPORTS:=$(w32api_lib)/libkernel32.a $(w32api_lib)/libadvapi32.a
MT_SAFE_OBJECTS:= MT_SAFE_OBJECTS:=
# Please maintain this list in sorted order, with maximum files per 85 col line # Please maintain this list in sorted order, with maximum files per 86 col line
# #
DLL_OFILES:=assert.o autoload.o bsdlib.o ctype.o cxx.o cygheap.o cygthread.o \ DLL_OFILES:=assert.o autoload.o bsdlib.o ctype.o cxx.o cygheap.o cygthread.o \
cygtls.o dcrt0.o debug.o delqueue.o devices.o dir.o dlfcn.o dll_init.o \ cygtls.o dcrt0.o debug.o delqueue.o devices.o dir.o dlfcn.o dll_init.o \
@ -129,8 +129,8 @@ DLL_OFILES:=assert.o autoload.o bsdlib.o ctype.o cxx.o cygheap.o cygthread.o \
fhandler_socket.o fhandler_tape.o fhandler_termios.o \ fhandler_socket.o fhandler_tape.o fhandler_termios.o \
fhandler_tty.o fhandler_virtual.o fhandler_windows.o fhandler_zero.o \ fhandler_tty.o fhandler_virtual.o fhandler_windows.o fhandler_zero.o \
flock.o fnmatch.o fork.o getopt.o glob.o grp.o heap.o hookapi.o \ flock.o fnmatch.o fork.o getopt.o glob.o grp.o heap.o hookapi.o \
init.o ioctl.o ipc.o iruserok.o localtime.o malloc_wrapper.o miscfuncs.o \ init.o ioctl.o ipc.o iruserok.o localtime.o lsearch.o malloc_wrapper.o \
mmap.o msg.o net.o netdb.o ntea.o passwd.o path.o pinfo.o pipe.o \ miscfuncs.o mmap.o msg.o net.o netdb.o ntea.o passwd.o path.o pinfo.o pipe.o \
poll.o pthread.o regcomp.o regerror.o regexec.o regfree.o \ poll.o pthread.o regcomp.o regerror.o regexec.o regfree.o \
registry.o resource.o scandir.o sched.o sec_acl.o sec_helper.o security.o \ registry.o resource.o scandir.o sched.o sec_acl.o sec_helper.o security.o \
select.o sem.o shared.o shm.o sigfe.o signal.o sigproc.o smallprint.o \ select.o sem.o shared.o shm.o sigfe.o signal.o sigproc.o smallprint.o \

15
winsup/cygwin/cygthread.cc
View File

@ -26,7 +26,7 @@ DWORD NO_COPY cygthread::main_thread_id;
bool NO_COPY cygthread::exiting; bool NO_COPY cygthread::exiting;
/* Initial stub called by cygthread constructor. Performs initial /* Initial stub called by cygthread constructor. Performs initial
per-thread initialization and loops waiting for new thread functions per-thread initialization and loops waiting for another thread function
to execute. */ to execute. */
DWORD WINAPI DWORD WINAPI
cygthread::stub (VOID *arg) cygthread::stub (VOID *arg)
@ -73,10 +73,11 @@ cygthread::stub (VOID *arg)
info->func (info->arg == cygself ? info : info->arg); info->func (info->arg == cygself ? info : info->arg);
/* ...so the above should always return */ /* ...so the above should always return */
HANDLE notify = info->notify_detached;
/* If func is NULL, the above function has set that to indicate /* If func is NULL, the above function has set that to indicate
that it doesn't want to alert anyone with a SetEvent and should that it doesn't want to alert anyone with a SetEvent and should
just be marked as no longer inuse. Hopefully the function knows just be marked as no longer inuse. Hopefully the function knows
that it is doing. */ what it is doing. */
if (!info->func) if (!info->func)
info->release (false); info->release (false);
else else
@ -88,6 +89,8 @@ cygthread::stub (VOID *arg)
info->__name = NULL; info->__name = NULL;
SetEvent (info->ev); SetEvent (info->ev);
} }
if (notify)
SetEvent (notify);
} }
switch (WaitForSingleObject (info->thread_sync, INFINITE)) switch (WaitForSingleObject (info->thread_sync, INFINITE))
{ {
@ -161,8 +164,8 @@ out:
} }
cygthread::cygthread (LPTHREAD_START_ROUTINE start, LPVOID param, cygthread::cygthread (LPTHREAD_START_ROUTINE start, LPVOID param,
const char *name): __name (name), const char *name, HANDLE notify)
func (start), arg (param) : __name (name), func (start), arg (param), notify_detached (notify)
{ {
thread_printf ("name %s, id %p", name, id); thread_printf ("name %s, id %p", name, id);
if (h) if (h)
@ -310,7 +313,9 @@ cygthread::detach (HANDLE sigwait)
DWORD res; DWORD res;
if (!sigwait) if (!sigwait)
res = WaitForSingleObject (*this, INFINITE); /* If the caller specified a special handle for notification, wait for that.
This assumes that the thread in question is auto releasing. */
res = WaitForSingleObject (notify_detached ?: *this, INFINITE);
else else
{ {
/* Lower our priority and give priority to the read thread */ /* Lower our priority and give priority to the read thread */

3
winsup/cygwin/cygthread.h
View File

@ -26,6 +26,7 @@ class cygthread
VOID *arg; VOID *arg;
bool is_freerange; bool is_freerange;
static bool exiting; static bool exiting;
HANDLE notify_detached;
public: public:
bool terminate_thread (); bool terminate_thread ();
static DWORD WINAPI stub (VOID *); static DWORD WINAPI stub (VOID *);
@ -34,7 +35,7 @@ class cygthread
static const char * name (DWORD = 0); static const char * name (DWORD = 0);
void auto_release () {func = NULL;} void auto_release () {func = NULL;}
void release (bool); void release (bool);
cygthread (LPTHREAD_START_ROUTINE, LPVOID, const char *); cygthread (LPTHREAD_START_ROUTINE, LPVOID, const char *, HANDLE = NULL);
cygthread () {}; cygthread () {};
static void init (); static void init ();
bool detach (HANDLE = NULL); bool detach (HANDLE = NULL);

2
winsup/cygwin/cygtls.cc
View File

@ -1,6 +1,6 @@
/* cygtls.cc /* cygtls.cc
Copyright 2003, 2004 Red Hat, Inc. Copyright 2003, 2004, 2005 Red Hat, Inc.
This software is a copyrighted work licensed under the terms of the This software is a copyrighted work licensed under the terms of the
Cygwin license. Please consult the file "CYGWIN_LICENSE" for Cygwin license. Please consult the file "CYGWIN_LICENSE" for

3
winsup/cygwin/cygwin.din
View File

@ -821,6 +821,7 @@ ldexpf NOSIGFE
_ldexpf = ldexpf NOSIGFE _ldexpf = ldexpf NOSIGFE
ldiv NOSIGFE ldiv NOSIGFE
_ldiv = ldiv NOSIGFE _ldiv = ldiv NOSIGFE
lfind NOSIGFE
lgamma NOSIGFE lgamma NOSIGFE
_lgamma = lgamma NOSIGFE _lgamma = lgamma NOSIGFE
lgamma_r NOSIGFE lgamma_r NOSIGFE
@ -866,6 +867,7 @@ lrint NOSIGFE
lrintf NOSIGFE lrintf NOSIGFE
lround NOSIGFE lround NOSIGFE
lroundf NOSIGFE lroundf NOSIGFE
lsearch NOSIGFE
lseek SIGFE lseek SIGFE
_lseek = lseek SIGFE _lseek = lseek SIGFE
_lseek64 = lseek64 SIGFE _lseek64 = lseek64 SIGFE
@ -1436,6 +1438,7 @@ time SIGFE
_time = time SIGFE _time = time SIGFE
timer_create SIGFE timer_create SIGFE
timer_delete SIGFE timer_delete SIGFE
timer_gettime SIGFE
timer_settime SIGFE timer_settime SIGFE
times SIGFE times SIGFE
_times = times SIGFE _times = times SIGFE

2
winsup/cygwin/debug.cc
View File

@ -1,6 +1,6 @@
/* debug.cc /* debug.cc
Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Red Hat, Inc. Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Red Hat, Inc.
This software is a copyrighted work licensed under the terms of the This software is a copyrighted work licensed under the terms of the
Cygwin license. Please consult the file "CYGWIN_LICENSE" for Cygwin license. Please consult the file "CYGWIN_LICENSE" for

23
winsup/cygwin/exceptions.cc
View File

@ -10,6 +10,8 @@ Cygwin license. Please consult the file "CYGWIN_LICENSE" for
details. */ details. */
#include "winsup.h" #include "winsup.h"
#include <wingdi.h>
#include <winuser.h>
#include <imagehlp.h> #include <imagehlp.h>
#include <stdlib.h> #include <stdlib.h>
#include <setjmp.h> #include <setjmp.h>
@ -782,6 +784,27 @@ out:
return interrupted; return interrupted;
} }
static inline bool
has_visible_window_station ()
{
HWINSTA station_hdl;
USEROBJECTFLAGS uof;
DWORD len;
/* Check if the process is associated with a visible window station.
These are processes running on the local desktop as well as processes
running in terminal server sessions.
Processes running in a service session not explicitely associated
with the desktop (using the "Allow service to interact with desktop"
property) are running in an invisible window station. */
if ((station_hdl = GetProcessWindowStation ())
&& GetUserObjectInformationA (station_hdl, UOI_FLAGS, &uof,
sizeof uof, &len)
&& (uof.dwFlags & WSF_VISIBLE))
return true;
return false;
}
/* Keyboard interrupt handler. */ /* Keyboard interrupt handler. */
static BOOL WINAPI static BOOL WINAPI
ctrl_c_handler (DWORD type) ctrl_c_handler (DWORD type)

2
winsup/cygwin/external.cc
View File

@ -1,6 +1,6 @@
/* external.cc: Interface to Cygwin internals from external programs. /* external.cc: Interface to Cygwin internals from external programs.
Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Red Hat, Inc. Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Red Hat, Inc.
Written by Christopher Faylor <cgf@cygnus.com> Written by Christopher Faylor <cgf@cygnus.com>

2
winsup/cygwin/fhandler_clipboard.cc
View File

@ -1,6 +1,6 @@
/* fhandler_dev_clipboard: code to access /dev/clipboard /* fhandler_dev_clipboard: code to access /dev/clipboard
Copyright 2000, 2001, 2002, 2003, 2004 Red Hat, Inc Copyright 2000, 2001, 2002, 2003, 2004, 2005 Red Hat, Inc
Written by Charles Wilson (cwilson@ece.gatech.edu) Written by Charles Wilson (cwilson@ece.gatech.edu)

2
winsup/cygwin/fhandler_mem.cc
View File

@ -1,6 +1,6 @@
/* fhandler_mem.cc. See fhandler.h for a description of the fhandler classes. /* fhandler_mem.cc. See fhandler.h for a description of the fhandler classes.
Copyright 2000, 2001, 2002, 2003, 2004 Red Hat, Inc. Copyright 2000, 2001, 2002, 2003, 2004, 2005 Red Hat, Inc.
This file is part of Cygwin. This file is part of Cygwin.

2
winsup/cygwin/fhandler_raw.cc
View File

@ -1,6 +1,6 @@
/* fhandler_raw.cc. See fhandler.h for a description of the fhandler classes. /* fhandler_raw.cc. See fhandler.h for a description of the fhandler classes.
Copyright 1999, 2000, 2001, 2002, 2003, 2004 Red Hat, Inc. Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005 Red Hat, Inc.
This file is part of Cygwin. This file is part of Cygwin.

2
winsup/cygwin/fhandler_serial.cc
View File

@ -1,6 +1,6 @@
/* fhandler_serial.cc /* fhandler_serial.cc
Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Red Hat, Inc. Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Red Hat, Inc.
This file is part of Cygwin. This file is part of Cygwin.

2
winsup/cygwin/fhandler_tape.cc
View File

@ -1,7 +1,7 @@
/* fhandler_tape.cc. See fhandler.h for a description of the fhandler /* fhandler_tape.cc. See fhandler.h for a description of the fhandler
classes. classes.
Copyright 1999, 2000, 2001, 2002, 2003, 2004 Red Hat, Inc. Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005 Red Hat, Inc.
This file is part of Cygwin. This file is part of Cygwin.

2
winsup/cygwin/fhandler_termios.cc
View File

@ -1,6 +1,6 @@
/* fhandler_termios.cc /* fhandler_termios.cc
Copyright 1999, 2000, 2001, 2002, 2003, 2004 Red Hat, Inc. Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005 Red Hat, Inc.
This file is part of Cygwin. This file is part of Cygwin.

2
winsup/cygwin/fhandler_windows.cc
View File

@ -1,6 +1,6 @@
/* fhandler_windows.cc: code to access windows message queues. /* fhandler_windows.cc: code to access windows message queues.
Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Red Hat, Inc. Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Red Hat, Inc.
Written by Sergey S. Okhapkin (sos@prospect.com.ru). Written by Sergey S. Okhapkin (sos@prospect.com.ru).
Feedback and testing by Andy Piper (andyp@parallax.co.uk). Feedback and testing by Andy Piper (andyp@parallax.co.uk).

3
winsup/cygwin/include/cygwin/version.h
View File

@ -252,12 +252,13 @@ details. */
123: Export utmpxname. 123: Export utmpxname.
124: Add MAP_AUTOGROW flag to mmap. 124: Add MAP_AUTOGROW flag to mmap.
125: LD_PRELOAD/CW_HOOK available. 125: LD_PRELOAD/CW_HOOK available.
126: Add lsearch, lfind, timer_gettime.
*/ */
/* Note that we forgot to bump the api for ualarm, strtoll, strtoull */ /* Note that we forgot to bump the api for ualarm, strtoll, strtoull */
#define CYGWIN_VERSION_API_MAJOR 0 #define CYGWIN_VERSION_API_MAJOR 0
#define CYGWIN_VERSION_API_MINOR 125 #define CYGWIN_VERSION_API_MINOR 126
/* There is also a compatibity version number associated with the /* There is also a compatibity version number associated with the
shared memory regions. It is incremented when incompatible shared memory regions. It is incremented when incompatible

64
winsup/cygwin/include/search.h Normal file
View File

@ -0,0 +1,64 @@
/*-
* Written by J.T. Conklin <jtc@netbsd.org>
* Public domain.
*
* $NetBSD: search.h,v 1.12 1999/02/22 10:34:28 christos Exp $
* $FreeBSD: src/include/search.h,v 1.10 2002/10/16 14:29:23 robert Exp $
*/
#ifndef _SEARCH_H_
#define _SEARCH_H_
#include <sys/cdefs.h>
#include <sys/types.h>
typedef struct entry
{
char *key;
void *data;
} ENTRY;
typedef enum
{
FIND, ENTER
} ACTION;
typedef enum
{
preorder,
postorder,
endorder,
leaf
} VISIT;
#ifdef _SEARCH_PRIVATE
typedef struct node
{
char *key;
struct node *llink, *rlink;
} node_t;
struct que_elem
{
struct que_elem *next;
struct que_elem *prev;
};
#endif
__BEGIN_DECLS
int hcreate (size_t);
void hdestroy (void);
ENTRY *hsearch (ENTRY, ACTION);
void *lfind (const void *, const void *, size_t *, size_t,
int (*) (const void *, const void *));
void *lsearch (const void *, void *, size_t *, size_t,
int (*) (const void *, const void *));
void *tdelete (const void * __restrict, void ** __restrict,
int (*) (const void *, const void *));
void *tfind (const void *, void * const *,
int (*) (const void *, const void *));
void *tsearch (const void *, void **, int (*) (const void *, const void *));
void twalk (const void *, void (*) (const void *, VISIT, int));
__END_DECLS
#endif /* !_SEARCH_H_ */

56
winsup/cygwin/lsearch.cc Normal file
View File

@ -0,0 +1,56 @@
/* Initial implementation:
Copyright (c) 2002 Robert Drehmel
All rights reserved.
As long as the above copyright statement and this notice remain
unchanged, you can do what ever you want with this file. */
#include <sys/types.h>
#include <sys/cdefs.h>
#define _SEARCH_PRIVATE
#include <search.h>
#include <stdint.h> /* for uint8_t */
#include <stdlib.h> /* for NULL */
#include <string.h> /* for memcpy () prototype */
static void *lwork (const void *, const void *, size_t *, size_t,
int (*) (const void *, const void *), int);
extern "C" void *
lsearch (const void *key, void *base, size_t *nelp, size_t width,
int (*compar) (const void *, const void *))
{
return lwork (key, base, nelp, width, compar, 1);
}
extern "C" void *
lfind (const void *key, const void *base, size_t *nelp, size_t width,
int (*compar) (const void *, const void *))
{
return lwork (key, base, nelp, width, compar, 0);
}
static void *
lwork (const void *key, const void *base, size_t *nelp, size_t width,
int (*compar) (const void *, const void *), int addelem)
{
uint8_t *ep, *endp;
/* Cast to an integer value first to avoid the warning for removing
'const' via a cast. */
ep = (uint8_t *) (uintptr_t)base;
for (endp = (uint8_t *) (ep + width * *nelp); ep < endp; ep += width)
if (compar (key, ep) == 0)
return ep;
/* lfind () shall return when the key was not found. */
if (!addelem)
return NULL;
/* lsearch () adds the key to the end of the table and increments
the number of elements. */
memcpy (endp, key, width);
++*nelp;
return endp;
}

2
winsup/cygwin/security.cc
View File

@ -1,6 +1,6 @@
/* security.cc: NT security functions /* security.cc: NT security functions
Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Red Hat, Inc. Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Red Hat, Inc.
Originaly written by Gunther Ebert, gunther.ebert@ixos-leipzig.de Originaly written by Gunther Ebert, gunther.ebert@ixos-leipzig.de
Completely rewritten by Corinna Vinschen <corinna@vinschen.de> Completely rewritten by Corinna Vinschen <corinna@vinschen.de>

2
winsup/cygwin/sync.cc
View File

@ -4,7 +4,7 @@
which is intended to operate similarly to a mutex but attempts to which is intended to operate similarly to a mutex but attempts to
avoid making expensive calls to the kernel. avoid making expensive calls to the kernel.
Copyright 2000, 2001, 2002, 2003, 2004 Red Hat, Inc. Copyright 2000, 2001, 2002, 2003, 2004, 2005 Red Hat, Inc.
Written by Christopher Faylor <cgf@cygnus.com> Written by Christopher Faylor <cgf@cygnus.com>

339
winsup/cygwin/timer.cc
View File

@ -22,27 +22,61 @@ details. */
#define TT_MAGIC 0x513e4a1c #define TT_MAGIC 0x513e4a1c
struct timer_tracker struct timer_tracker
{ {
static muto *protect;
unsigned magic; unsigned magic;
clockid_t clock_id; clockid_t clock_id;
sigevent evp; sigevent evp;
itimerspec it; timespec it_interval;
HANDLE cancel; HANDLE cancel;
int flags; HANDLE syncthread;
long long interval_us;
long long sleepto_us;
cygthread *th; cygthread *th;
struct timer_tracker *next; struct timer_tracker *next;
int settime (int, const itimerspec *, itimerspec *); int settime (int, const itimerspec *, itimerspec *);
void gettime (itimerspec *);
timer_tracker (clockid_t, const sigevent *); timer_tracker (clockid_t, const sigevent *);
timer_tracker (); timer_tracker () {};
~timer_tracker ();
friend void fixup_timers_after_fork ();
}; };
timer_tracker ttstart; timer_tracker NO_COPY ttstart;
muto *timer_tracker::protect; class lock_timer_tracker
timer_tracker::timer_tracker ()
{ {
new_muto (protect); static muto *protect;
public:
lock_timer_tracker ();
~lock_timer_tracker ();
};
muto NO_COPY *lock_timer_tracker::protect;
lock_timer_tracker::lock_timer_tracker ()
{
new_muto (protect)->acquire ();
}
lock_timer_tracker::~lock_timer_tracker ()
{
protect->release ();
}
timer_tracker::~timer_tracker ()
{
if (cancel)
{
SetEvent (cancel);
th->detach ();
CloseHandle (cancel);
#ifdef DEBUGGING
th = NULL;
cancel = NULL;
#endif
}
if (syncthread)
CloseHandle (syncthread);
magic = 0;
} }
timer_tracker::timer_tracker (clockid_t c, const sigevent *e) timer_tracker::timer_tracker (clockid_t c, const sigevent *e)
@ -56,84 +90,83 @@ timer_tracker::timer_tracker (clockid_t c, const sigevent *e)
evp.sigev_value.sival_ptr = this; evp.sigev_value.sival_ptr = this;
} }
clock_id = c; 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; magic = TT_MAGIC;
if (this != &ttstart)
{
cancel = NULL;
lock_timer_tracker here;
next = ttstart.next;
ttstart.next = this;
}
} }
static long long static long long
to_us (timespec& ts) to_us (const timespec& ts)
{ {
long long res = ts.tv_sec; long long res = ts.tv_sec;
res *= 1000000; res *= 1000000;
res += ts.tv_nsec / 1000 + ((ts.tv_nsec % 1000) >= 500 ? 1 : 0); res += ts.tv_nsec / 1000 + ((ts.tv_nsec % 1000) ? 1 : 0);
return res; return res;
} }
static NO_COPY itimerspec itzero;
static NO_COPY timespec tzero;
static DWORD WINAPI static DWORD WINAPI
timer_thread (VOID *x) timer_thread (VOID *x)
{ {
timer_tracker *tp = ((timer_tracker *) x); timer_tracker *tt = ((timer_tracker *) x);
timer_tracker tt = *tp; long long now;
for (bool first = true; ; first = false) long long sleepto_us = tt->sleepto_us;
while (1)
{ {
long long sleep_us = to_us (first ? tt.it.it_value : tt.it.it_interval); long long sleep_us;
long long sleep_to = sleep_us; long sleep_ms;
long long now = gtod.usecs (false); /* Account for delays in starting thread
if (tt.flags & TIMER_ABSTIME) and sending the signal */
sleep_us -= now; now = gtod.usecs (false);
sleep_us = sleepto_us - now;
if (sleep_us > 0)
{
tt->sleepto_us = sleepto_us;
sleep_ms = (sleep_us + 999) / 1000;
}
else else
sleep_to += now; {
tt->sleepto_us = now;
sleep_ms = 0;
}
DWORD sleep_ms = (sleep_us < 0) ? 0 : (sleep_us / 1000); debug_printf ("%p waiting for %u ms", x, sleep_ms);
debug_printf ("%p waiting for %u ms, first %d", x, sleep_ms, first); switch (WaitForSingleObject (tt->cancel, sleep_ms))
tp->it.it_value = tzero;
switch (WaitForSingleObject (tt.cancel, sleep_ms))
{ {
case WAIT_TIMEOUT: case WAIT_TIMEOUT:
debug_printf ("timed out"); debug_printf ("timed out");
break; break;
case WAIT_OBJECT_0: case WAIT_OBJECT_0:
now = gtod.usecs (false); debug_printf ("%p cancelled", x);
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; goto out;
default: default:
debug_printf ("%p timer wait failed, %E", x); debug_printf ("%p wait failed, %E", x);
goto out; goto out;
} }
switch (tt.evp.sigev_notify) switch (tt->evp.sigev_notify)
{ {
case SIGEV_SIGNAL: case SIGEV_SIGNAL:
{ {
siginfo_t si; siginfo_t si;
memset (&si, 0, sizeof (si)); memset (&si, 0, sizeof (si));
si.si_signo = tt.evp.sigev_signo; si.si_signo = tt->evp.sigev_signo;
si.si_sigval.sival_ptr = tt.evp.sigev_value.sival_ptr; si.si_sigval.sival_ptr = tt->evp.sigev_value.sival_ptr;
debug_printf ("%p sending sig %d", x, tt.evp.sigev_signo); debug_printf ("%p sending sig %d", x, tt->evp.sigev_signo);
sig_send (NULL, si); sig_send (myself_nowait, si);
break; break;
} }
case SIGEV_THREAD: case SIGEV_THREAD:
{ {
pthread_t notify_thread; pthread_t notify_thread;
debug_printf ("%p starting thread", x); debug_printf ("%p starting thread", x);
int rc = pthread_create (&notify_thread, tt.evp.sigev_notify_attributes, int rc = pthread_create (&notify_thread, tt->evp.sigev_notify_attributes,
(void * (*) (void *)) tt.evp.sigev_notify_function, (void * (*) (void *)) tt->evp.sigev_notify_function,
tt.evp.sigev_value.sival_ptr); tt->evp.sigev_value.sival_ptr);
if (rc) if (rc)
{ {
debug_printf ("thread creation failed, %E"); debug_printf ("thread creation failed, %E");
@ -143,17 +176,15 @@ timer_thread (VOID *x)
break; break;
} }
} }
if (!tt.it.it_interval.tv_sec && !tt.it.it_interval.tv_nsec) if (!tt->interval_us)
break; break;
tt.flags = 0;
sleepto_us = tt->sleepto_us + tt->interval_us;
debug_printf ("looping"); debug_printf ("looping");
} }
out: out:
CloseHandle (tt.cancel); _my_tls._ctinfo->auto_release (); /* automatically return the cygthread to the cygthread pool */
// FIXME: race here but is it inevitable?
if (tt.cancel == tp->cancel)
tp->cancel = NULL;
return 0; return 0;
} }
@ -177,48 +208,83 @@ timer_tracker::settime (int in_flags, const itimerspec *value, itimerspec *ovalu
return -1; return -1;
} }
if (__check_invalid_read_ptr_errno (value, sizeof (*value))) if (__check_invalid_read_ptr_errno (value, sizeof (*value))
|| it_bad (value->it_value)
|| it_bad (value->it_interval)
|| (ovalue && check_null_invalid_struct_errno (ovalue)))
return -1; return -1;
if (ovalue && check_null_invalid_struct_errno (ovalue)) long long now = in_flags & TIMER_ABSTIME ? 0 : gtod.usecs (false);
return -1;
itimerspec *elapsed; lock_timer_tracker here;
if (!cancel) if (cancel)
elapsed = &itzero;
else
{ {
SetEvent (cancel); // should be closed when the thread exits SetEvent (cancel); // should be closed when the thread exits
th->detach (); th->detach ();
elapsed = &it;
} }
if (ovalue) if (ovalue)
*ovalue = *elapsed; gettime (ovalue);
if (value->it_value.tv_sec || value->it_value.tv_nsec) if (value->it_value.tv_sec || value->it_value.tv_nsec)
{ {
if (it_bad (value->it_value)) sleepto_us = now + to_us (value->it_value);
return -1; interval_us = to_us (value->it_interval);
if (it_bad (value->it_interval)) it_interval = value->it_interval;
return -1; if (!cancel)
flags = in_flags; cancel = CreateEvent (&sec_none_nih, TRUE, FALSE, NULL);
cancel = CreateEvent (&sec_none_nih, TRUE, FALSE, NULL); else
it = *value; ResetEvent (cancel);
th = new cygthread (timer_thread, this, "itimer"); if (!syncthread)
syncthread = CreateEvent (&sec_none_nih, TRUE, FALSE, NULL);
else
ResetEvent (syncthread);
th = new cygthread (timer_thread, this, "itimer", syncthread);
} }
return 0; return 0;
} }
void
timer_tracker::gettime (itimerspec *ovalue)
{
if (!cancel)
memset (ovalue, 0, sizeof (*ovalue));
else
{
ovalue->it_interval = it_interval;
long long now = gtod.usecs (false);
long long left_us = sleepto_us - now;
if (left_us < 0)
left_us = 0;
ovalue->it_value.tv_sec = left_us / 1000000;
ovalue->it_value.tv_nsec = (left_us % 1000000) * 1000;
}
}
extern "C" int
timer_gettime (timer_t timerid, struct itimerspec *ovalue)
{
if (check_null_invalid_struct_errno (ovalue))
return -1;
timer_tracker *tt = (timer_tracker *) timerid;
if (check_null_invalid_struct (tt) || tt->magic != TT_MAGIC)
{
set_errno (EINVAL);
return -1;
}
tt->gettime (ovalue);
return 0;
}
extern "C" int extern "C" int
timer_create (clockid_t clock_id, struct sigevent *evp, timer_t *timerid) timer_create (clockid_t clock_id, struct sigevent *evp, timer_t *timerid)
{ {
if (evp && check_null_invalid_struct_errno (evp)) if (evp && check_null_invalid_struct_errno (evp)
|| check_null_invalid_struct_errno (timerid))
return -1; return -1;
if (check_null_invalid_struct_errno (timerid))
return -1;
if (clock_id != CLOCK_REALTIME) if (clock_id != CLOCK_REALTIME)
{ {
set_errno (EINVAL); set_errno (EINVAL);
@ -234,8 +300,12 @@ timer_settime (timer_t timerid, int flags, const struct itimerspec *value,
struct itimerspec *ovalue) struct itimerspec *ovalue)
{ {
timer_tracker *tt = (timer_tracker *) timerid; timer_tracker *tt = (timer_tracker *) timerid;
if (check_null_invalid_struct_errno (tt) || tt->magic != TT_MAGIC) if (check_null_invalid_struct (tt) || tt->magic != TT_MAGIC)
return -1; {
set_errno (EINVAL);
return -1;
}
return tt->settime (flags, value, ovalue); return tt->settime (flags, value, ovalue);
} }
@ -243,21 +313,20 @@ extern "C" int
timer_delete (timer_t timerid) timer_delete (timer_t timerid)
{ {
timer_tracker *in_tt = (timer_tracker *) timerid; timer_tracker *in_tt = (timer_tracker *) timerid;
if (check_null_invalid_struct_errno (in_tt) || in_tt->magic != TT_MAGIC) if (check_null_invalid_struct (in_tt) || in_tt->magic != TT_MAGIC)
return -1; {
set_errno (EINVAL);
return -1;
}
timer_tracker::protect->acquire (); lock_timer_tracker here;
for (timer_tracker *tt = &ttstart; tt->next != NULL; tt = tt->next) for (timer_tracker *tt = &ttstart; tt->next != NULL; tt = tt->next)
if (tt->next == in_tt) if (tt->next == in_tt)
{ {
timer_tracker *deleteme = tt->next; tt->next = in_tt->next;
tt->next = deleteme->next; delete in_tt;
delete deleteme;
timer_tracker::protect->release ();
return 0; return 0;
} }
timer_tracker::protect->release ();
set_errno (EINVAL); set_errno (EINVAL);
return 0; return 0;
} }
@ -265,10 +334,104 @@ timer_delete (timer_t timerid)
void void
fixup_timers_after_fork () fixup_timers_after_fork ()
{ {
ttstart.cancel = ttstart.syncthread = NULL;
for (timer_tracker *tt = &ttstart; tt->next != NULL; /* nothing */) for (timer_tracker *tt = &ttstart; tt->next != NULL; /* nothing */)
{ {
timer_tracker *deleteme = tt->next; timer_tracker *deleteme = tt->next;
tt->next = deleteme->next; tt->next = deleteme->next;
deleteme->cancel = deleteme->syncthread = NULL;
delete deleteme; delete deleteme;
} }
} }
extern "C" int
setitimer (int which, const struct itimerval *value, struct itimerval *ovalue)
{
if (which != ITIMER_REAL)
{
set_errno (EINVAL);
return -1;
}
struct itimerspec spec_value, spec_ovalue;
int ret;
spec_value.it_interval.tv_sec = value->it_interval.tv_sec;
spec_value.it_interval.tv_nsec = value->it_interval.tv_usec * 1000;
spec_value.it_value.tv_sec = value->it_value.tv_sec;
spec_value.it_value.tv_nsec = value->it_value.tv_usec * 1000;
ret = timer_settime ((timer_t) &ttstart, 0, &spec_value, &spec_ovalue);
if (!ret && ovalue)
{
ovalue->it_interval.tv_sec = spec_ovalue.it_interval.tv_sec;
ovalue->it_interval.tv_usec = spec_ovalue.it_interval.tv_nsec / 1000;
ovalue->it_value.tv_sec = spec_ovalue.it_value.tv_sec;
ovalue->it_value.tv_usec = spec_ovalue.it_value.tv_nsec / 1000;
}
syscall_printf ("%d = setitimer ()", ret);
return ret;
}
extern "C" int
getitimer (int which, struct itimerval *ovalue)
{
if (which != ITIMER_REAL)
{
set_errno (EINVAL);
return -1;
}
if (ovalue == NULL)
{
set_errno (EFAULT);
return -1;
}
struct itimerspec spec_ovalue;
int ret = timer_gettime ((timer_t) &ttstart, &spec_ovalue);
if (!ret)
{
ovalue->it_interval.tv_sec = spec_ovalue.it_interval.tv_sec;
ovalue->it_interval.tv_usec = spec_ovalue.it_interval.tv_nsec / 1000;
ovalue->it_value.tv_sec = spec_ovalue.it_value.tv_sec;
ovalue->it_value.tv_usec = spec_ovalue.it_value.tv_nsec / 1000;
}
syscall_printf ("%d = getitimer ()", ret);
return ret;
}
/* FIXME: POSIX - alarm survives exec */
extern "C" unsigned int
alarm (unsigned int seconds)
{
struct itimerspec newt = {}, oldt;
/* alarm cannot fail, but only needs not be
correct for arguments < 64k. Truncate */
if (seconds > (HIRES_DELAY_MAX / 1000 - 1))
seconds = (HIRES_DELAY_MAX / 1000 - 1);
newt.it_value.tv_sec = seconds;
timer_settime ((timer_t) &ttstart, 0, &newt, &oldt);
int ret = oldt.it_value.tv_sec + (oldt.it_value.tv_nsec > 0);
syscall_printf ("%d = alarm (%d)", ret, seconds);
return ret;
}
extern "C" useconds_t
ualarm (useconds_t value, useconds_t interval)
{
struct itimerspec timer = {}, otimer;
/* ualarm cannot fail.
Interpret negative arguments as zero */
if (value > 0)
{
timer.it_value.tv_sec = (unsigned int) value / 1000000;
timer.it_value.tv_nsec = ((unsigned int) value % 1000000) * 1000;
}
if (interval > 0)
{
timer.it_interval.tv_sec = (unsigned int) interval / 1000000;
timer.it_interval.tv_nsec = ((unsigned int) interval % 1000000) * 1000;
}
timer_settime ((timer_t) &ttstart, 0, &timer, &otimer);
useconds_t ret = otimer.it_value.tv_sec * 1000000 + (otimer.it_value.tv_nsec + 999) / 1000;
syscall_printf ("%d = ualarm (%d , %d)", ret, value, interval);
return ret;
}

179
winsup/cygwin/window.cc
View File

@ -1,6 +1,6 @@
/* window.cc: hidden windows for signals/itimer support /* window.cc: hidden windows for signals/itimer support
Copyright 1997, 1998, 2000, 2001, 2002, 2003, 2004 Red Hat, Inc. Copyright 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005 Red Hat, Inc.
Written by Sergey Okhapkin <sos@prospect.com.ru> Written by Sergey Okhapkin <sos@prospect.com.ru>
@ -30,12 +30,7 @@ details. */
wininfo NO_COPY winmsg; wininfo NO_COPY winmsg;
muto NO_COPY *wininfo::lock; muto NO_COPY *wininfo::_lock;
wininfo::wininfo ()
{
new_muto_name (lock, "!winlock");
}
int __stdcall int __stdcall
wininfo::process (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) wininfo::process (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
@ -50,23 +45,6 @@ wininfo::process (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
case WM_DESTROY: case WM_DESTROY:
PostQuitMessage (0); PostQuitMessage (0);
return 0; return 0;
case WM_TIMER:
if (wParam == timer_active)
{
UINT elapse = itv.it_interval.tv_sec * 1000 +
itv.it_interval.tv_usec / 1000;
KillTimer (hwnd, timer_active);
if (!elapse)
timer_active = 0;
else
{
timer_active = SetTimer (hwnd, 1, elapse, NULL);
start_time = GetTickCount ();
itv.it_value = itv.it_interval;
}
raise (SIGALRM);
}
return 0;
case WM_ASYNCIO: case WM_ASYNCIO:
if (WSAGETSELECTEVENT (lParam) == FD_OOB) if (WSAGETSELECTEVENT (lParam) == FD_OOB)
raise (SIGURG); raise (SIGURG);
@ -92,7 +70,7 @@ wininfo::winthread ()
WNDCLASS wc; WNDCLASS wc;
static NO_COPY char classname[] = "CygwinWndClass"; static NO_COPY char classname[] = "CygwinWndClass";
lock->grab (); _lock->grab ();
/* Register the window class for the main window. */ /* Register the window class for the main window. */
wc.style = 0; wc.style = 0;
@ -116,7 +94,7 @@ wininfo::winthread ()
(LPVOID) NULL); (LPVOID) NULL);
if (!hwnd) if (!hwnd)
api_fatal ("couldn't create window, %E"); api_fatal ("couldn't create window, %E");
lock->release (); release ();
while (GetMessage (&msg, hwnd, 0, 0) == TRUE) while (GetMessage (&msg, hwnd, 0, 0) == TRUE)
DispatchMessage (&msg); DispatchMessage (&msg);
@ -136,156 +114,27 @@ HWND ()
if (hwnd) if (hwnd)
return hwnd; return hwnd;
lock->acquire (); lock ();
if (!hwnd) if (!hwnd)
{ {
lock->upforgrabs (); _lock->upforgrabs ();
cygthread *h = new cygthread (::winthread, this, "win"); cygthread *h = new cygthread (::winthread, this, "win");
h->SetThreadPriority (THREAD_PRIORITY_HIGHEST); h->SetThreadPriority (THREAD_PRIORITY_HIGHEST);
h->zap_h (); h->zap_h ();
lock->acquire (); lock ();
} }
lock->release (); release ();
return hwnd; return hwnd;
} }
extern "C" int void
setitimer (int which, const struct itimerval *value, struct itimerval *oldvalue) wininfo::lock ()
{ {
if (which != ITIMER_REAL) new_muto (_lock)->acquire ();
{
set_errno (ENOSYS);
return -1;
}
return winmsg.setitimer (value, oldvalue);
} }
/* FIXME: Very racy */ void
int __stdcall wininfo::release ()
wininfo::setitimer (const struct itimerval *value, struct itimerval *oldvalue)
{ {
/* Check if we will wrap */ _lock->release ();
if (itv.it_value.tv_sec >= (long) (UINT_MAX / 1000))
{
set_errno (EINVAL);
return -1;
}
if (timer_active)
{
KillTimer (winmsg, timer_active);
timer_active = 0;
}
if (oldvalue)
*oldvalue = itv;
if (value == NULL)
{
set_errno (EFAULT);
return -1;
}
itv = *value;
UINT elapse = itv.it_value.tv_sec * 1000 + itv.it_value.tv_usec / 1000;
if (elapse == 0)
if (itv.it_value.tv_usec)
elapse = 1;
else
return 0;
if (!(timer_active = SetTimer (winmsg, 1, elapse, NULL)))
{
__seterrno ();
return -1;
}
start_time = GetTickCount ();
return 0;
}
extern "C" int
getitimer (int which, struct itimerval *value)
{
if (which != ITIMER_REAL)
{
set_errno (EINVAL);
return -1;
}
if (value == NULL)
{
set_errno (EFAULT);
return -1;
}
return winmsg.getitimer (value);
}
/* FIXME: racy */
int __stdcall
wininfo::getitimer (struct itimerval *value)
{
*value = itv;
if (!timer_active)
{
value->it_value.tv_sec = 0;
value->it_value.tv_usec = 0;
return 0;
}
UINT elapse, val;
elapse = GetTickCount () - start_time;
val = itv.it_value.tv_sec * 1000 + itv.it_value.tv_usec / 1000;
val -= elapse;
value->it_value.tv_sec = val / 1000;
value->it_value.tv_usec = val % 1000;
return 0;
}
extern "C" unsigned int
alarm (unsigned int seconds)
{
int ret;
struct itimerval newt, oldt;
newt.it_value.tv_sec = seconds;
newt.it_value.tv_usec = 0;
newt.it_interval.tv_sec = 0;
newt.it_interval.tv_usec = 0;
setitimer (ITIMER_REAL, &newt, &oldt);
ret = oldt.it_value.tv_sec;
if (ret == 0 && oldt.it_value.tv_usec)
ret = 1;
return ret;
}
extern "C" useconds_t
ualarm (useconds_t value, useconds_t interval)
{
struct itimerval timer, otimer;
timer.it_value.tv_sec = 0;
timer.it_value.tv_usec = value;
timer.it_interval.tv_sec = 0;
timer.it_interval.tv_usec = interval;
if (setitimer (ITIMER_REAL, &timer, &otimer) < 0)
return (u_int)-1;
return (otimer.it_value.tv_sec * 1000000) + otimer.it_value.tv_usec;
}
bool
has_visible_window_station (void)
{
HWINSTA station_hdl;
USEROBJECTFLAGS uof;
DWORD len;
/* Check if the process is associated with a visible window station.
These are processes running on the local desktop as well as processes
running in terminal server sessions.
Processes running in a service session not explicitely associated
with the desktop (using the "Allow service to interact with desktop"
property) are running in an invisible window station. */
if ((station_hdl = GetProcessWindowStation ())
&& GetUserObjectInformationA (station_hdl, UOI_FLAGS, &uof,
sizeof uof, &len)
&& (uof.dwFlags & WSF_VISIBLE))
return true;
return false;
} }

13
winsup/cygwin/wininfo.h
View File

@ -12,20 +12,13 @@ class muto;
class wininfo class wininfo
{ {
HWND hwnd; HWND hwnd;
static muto *lock; static muto *_lock;
public: public:
UINT timer_active;
struct itimerval itv;
DWORD start_time;
HANDLE window_started;
operator HWND (); operator HWND ();
int __stdcall wininfo::process (HWND, UINT, WPARAM, LPARAM) int __stdcall wininfo::process (HWND, UINT, WPARAM, LPARAM)
__attribute__ ((regparm (3))); __attribute__ ((regparm (3)));
int __stdcall setitimer (const struct itimerval *value, struct itimerval *oldvalue) void lock ();
__attribute__ ((regparm (3))); void release ();
int __stdcall getitimer (struct itimerval *value)
__attribute__ ((regparm (2)));
wininfo ();
DWORD WINAPI winthread () __attribute__ ((regparm (1))); DWORD WINAPI winthread () __attribute__ ((regparm (1)));
}; };

3
winsup/cygwin/winsup.h
View File

@ -223,9 +223,6 @@ void events_terminate (void);
void __stdcall close_all_files (); void __stdcall close_all_files ();
/* Check if running in a visible window station. */
extern bool has_visible_window_station (void);
/* Globals that handle initialization of winsock in a child process. */ /* Globals that handle initialization of winsock in a child process. */
extern HANDLE wsock32_handle; extern HANDLE wsock32_handle;
extern HANDLE ws2_32_handle; extern HANDLE ws2_32_handle;