+Mon Oct 16 18:37:22 2000 Christopher Faylor <cgf@cygnus.com>
+
+ * Makefile.in: Remove some obsolete stuff.
+ * dcrt0.cc (dll_crt0_1): Call signal_fixup_after_exec where appropriate.
+ Set myself->uid from parent version.
+ Just use ThreadItem Init method. Close or store hexec_proc as appropriate.
+ (_dll_crt0): Store user_data->forkee here so that proper tests can be made
+ subsequently.
+ (do_exit): Remove hExeced stuff.
+ * environ.cc (environ_init): Accept environ count as well as environ pointer.
+ * environ.h: Reflect above change.
+ * pinfo.cc (pinfo_init): Ditto. Accept environ count.
+ (fixup_in_spawned_child): Remove.
+ * spawn.cc (spawn_guts): Move signal code to dll_crt0_1. Don't suspend
+ execing process since it is no longer necessary. Store envc.
+ * exceptions.cc (signal_fixup_after_exec): New function.
+ (call_handler): Remove hExeced test.
+ * child_info.h (cygheap_exec_info): Store envc as well as envp.
+ (child_info_spawn): Store hexec_proc so that it can be closed in child.
+ * path.cc (normalize_posix_path): Avoid intermediate use of temporary cwd buf.
+ (normalize_win32_path): Ditto.
+ (cwdstuff::get_initial): Always set lock.
+ * sigproc.h: Remove hExeced.
+ * strace.cc (strace::vsprntf): Modify to accomodate for lack of hExeced.
+ * thread.cc (MTinterface::Init): Merge Init1 and ClearReent into this method.
+ (MTinterface::Init1): Eliminate.
+ (MTinterface::ClearReent): Eliminate.
+ * thread.h: Reflect above changes.
+ * include/sys/strace.h (strace): Make microseconds() public.
+
+Sun Oct 15 21:54:52 2000 Christopher Faylor <cgf@cygnus.com>
+
+ Make various functions 'regparm', throughout.
+ * pinfo.h (_pinfo): Inline simple signal manipulation functions.
+ Requires inclusion of thread.h which was removed from .cc files, where
+ appropriate. throughout.
+ * pinfo.cc: Eliminate signal manipulation functions.
+ (_pinfo::exit): Calculate total rusage for exiting process here.
+ * cygheap.cc (size2bucket): Eliminate.
+ (init_buckets): Ditto.
+ (_cmalloc): Calculate size and bits in a loop rather than going through
+ a function call.
+ (_crealloc): Use stored array index to calculate allocated size.
+ * spawn.cc (spawn_guts): Use _pinfo exit method to exit, calculating
+ cpu usage.
+
Sat Oct 14 21:24:16 2000 Christopher Faylor <cgf@cygnus.com>
* exceptions.cc (set_console_handler): Don't allocate
# FIXME: Which is it, CC or CC_FOR_TARGET?
CC_FOR_TARGET:=$(CC)
CFLAGS:=@CFLAGS@
-CFLAGS+=-MD
+CFLAGS+=-MD -fbuiltin
CXXFLAGS:=@CXXFLAGS@
# For linking mount, etc. crt0.o isn't accessable in a fresh build.
else echo runtest; fi`
RUNTESTFLAGS =
-ifdef MT_SAFE
-MT_SAFE_HEADERS:=thread.h
-MT_SAFE_OBJECTS:=pthread.o thread.o
-endif
-
# Parameters used in building the cygwin.dll.
# We build as new-cygwin.dll and rename at install time to overcome
# native rebuilding issues (we don't want the build tools to see a partially
fhandler_random.o fhandler_raw.o fhandler_serial.o fhandler_tape.o \
fhandler_termios.o fhandler_tty.o fhandler_windows.o fhandler_zero.o \
fork.o glob.o grp.o heap.o init.o ioctl.o localtime.o malloc.o mmap.o \
- net.o ntea.o passwd.o path.o pinfo.o pipe.o poll.o regexp.o regerror.o \
- regsub.o registry.o resource.o scandir.o security.o select.o shared.o \
- signal.o sigproc.o smallprint.o spawn.o strace.o strsep.o sync.o \
- syscalls.o sysconf.o syslog.o termios.o times.o tty.o uinfo.o uname.o \
- wait.o window.o \
+ net.o ntea.o passwd.o path.o pinfo.o pipe.o poll.o pthread.o regexp.o \
+ regerror.o regsub.o registry.o resource.o scandir.o security.o select.o \
+ shared.o signal.o sigproc.o smallprint.o spawn.o strace.o strsep.o \
+ sync.o syscalls.o sysconf.o syslog.o termios.o thread.o times.o tty.o \
+ uinfo.o uname.o wait.o window.o \
$(EXTRA_DLL_OFILES) $(EXTRA_OFILES) $(MT_SAFE_OBJECTS)
GMON_OFILES:= gmon.o mcount.o profil.o
$(DEF_FILE): cygwin.din config.status
$(SHELL) config.status
-# .h file dependencies
-# This may be overkill, but it's better than the previous situation.
-# As files/dependencies are added and removed from Cygwin, please keep
-# this list up to date.
-
-WINSUP_H:=winsup.h fhandler.h path.h shared.h \
- sigproc.h include/cygwin/version.h \
- $(MT_SAFE_HEADERS)
-
winsup.h: config.h
ifneq (,${wildcard *.d})
class cygheap_exec_info
{
public:
+ uid_t uid;
char *old_title;
fhandler_base **fds;
size_t nfds;
int argc;
char **argv;
- char **environ;
+ int envc;
+ char **envp;
HANDLE myself_pinfo;
char *cwd_posix;
char *cwd_win32;
{
public:
cygheap_exec_info *moreinfo;
+ HANDLE hexec_proc;
child_info_spawn (): moreinfo (NULL) {}
~child_info_spawn ()
cfree (moreinfo->cwd_posix);
if (moreinfo->cwd_win32)
cfree (moreinfo->cwd_win32);
- if (moreinfo->environ)
+ if (moreinfo->envp)
{
- for (char **e = moreinfo->environ; *e; e++)
+ for (char **e = moreinfo->envp; *e; e++)
cfree (*e);
- cfree (moreinfo->environ);
+ cfree (moreinfo->envp);
}
CloseHandle (moreinfo->myself_pinfo);
cfree (moreinfo);
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
details. */
-void __stdcall seterrno_from_win_error (const char *file, int line, DWORD code);
-void __stdcall seterrno (const char *, int line);
-int __stdcall geterrno_from_win_error (DWORD code, int deferrno);
+void __stdcall seterrno_from_win_error (const char *file, int line, DWORD code) __attribute__ ((regparm(3)));
+void __stdcall seterrno (const char *, int line) __attribute__ ((regparm(2)));
+int __stdcall geterrno_from_win_error (DWORD code, int deferrno) __attribute__ ((regparm(2)));
#define __seterrno() seterrno (__FILE__, __LINE__)
#define __seterrno_from_win_error(val) seterrno_from_win_error (__FILE__, __LINE__, val)
#define NBUCKETS 32
char *buckets[NBUCKETS] = {0};
-int bucket2size[NBUCKETS] = {0};
-
-static inline int
-size2bucket (int size)
-{
- int rv = 0x1f;
- int bit = ~0x10;
- int i;
-
- if (size < 4)
- size = 4;
- size = (size + 3) & ~3;
-
- for (i = 0; i < 5; i++)
- {
- if (bucket2size[rv & bit] >= size)
- rv &= bit;
- bit >>= 1;
- }
- return rv;
-}
-
-static inline void
-init_buckets ()
-{
- unsigned b;
- for (b = 0; b < NBUCKETS; b++)
- bucket2size[b] = (1 << b);
-}
struct _cmalloc_entry
{
#define to_cmalloc(s) ((_cmalloc_entry *) (((char *) (s)) - (int) (N0->data)))
#define cygheap_chain ((_cmalloc_entry **)cygheap)
+static void *_cmalloc (int size) __attribute ((regparm(1)));
+static void *__stdcall _crealloc (void *ptr, int size) __attribute ((regparm(2)));
+
static void *__stdcall
_cmalloc (int size)
{
_cmalloc_entry *rvc;
- int b;
+ int b, sz;
- if (bucket2size[0] == 0)
- init_buckets ();
+ /* Calculate "bit bucket" and size as a power of two. */
+ for (b = 3, sz = 8; sz && sz < (size + 4); b++, sz <<= 1)
+ continue;
- b = size2bucket (size);
cygheap_protect->acquire ();
if (buckets[b])
{
}
else
{
- size = bucket2size[b] + sizeof (_cmalloc_entry);
+ size = sz + sizeof (_cmalloc_entry);
rvc = (_cmalloc_entry *) _csbrk (size);
rvc->b = b;
newptr = _cmalloc (size);
else
{
- int oldsize = bucket2size[to_cmalloc (ptr)->b];
+ int oldsize = 1 << to_cmalloc (ptr)->b;
if (size <= oldsize)
return ptr;
newptr = _cmalloc (size);
}
}
-static void *__stdcall
+inline static void *
creturn (cygheap_types x, cygheap_entry * c, int len)
{
if (!c)
#define incygheap(s) (cygheap && ((char *) (s) >= (char *) cygheap) && ((char *) (s) <= ((char *) cygheap_max)))
extern "C" {
-void __stdcall cfree (void *);
+void __stdcall cfree (void *) __attribute__ ((regparm(1)));
void __stdcall cygheap_fixup_in_child (HANDLE, bool);
-void *__stdcall cmalloc (cygheap_types, DWORD);
-void *__stdcall crealloc (void *, DWORD);
-void *__stdcall ccalloc (cygheap_types, DWORD, DWORD);
-char *__stdcall cstrdup (const char *);
-char *__stdcall cstrdup1 (const char *);
+void *__stdcall cmalloc (cygheap_types, DWORD) __attribute__ ((regparm(2)));
+void *__stdcall crealloc (void *, DWORD) __attribute__ ((regparm(2)));
+void *__stdcall ccalloc (cygheap_types, DWORD, DWORD) __attribute__ ((regparm(3)));
+char *__stdcall cstrdup (const char *) __attribute__ ((regparm(1)));
+char *__stdcall cstrdup1 (const char *) __attribute__ ((regparm(1)));
void __stdcall cygheap_init ();
}
#include "exceptions.h"
#include "autoload.h"
#include <ctype.h>
+#include <limits.h>
#include "sync.h"
#include "sigproc.h"
#include "pinfo.h"
#include "perthread.h"
#include "path.h"
#include "dtable.h"
-#include "thread.h"
#include "shared_info.h"
#include "cygwin_version.h"
#include "perprocess.h"
_impure_ptr = &reent_data;
user_data->resourcelocks->Init ();
- user_data->threadinterface->Init0 ();
+ user_data->threadinterface->Init (user_data->forkee);
threadname_init ();
debug_init ();
regthread ("main", GetCurrentThreadId ());
+ int envc = 0;
char **envp = NULL;
if (child_proc_info)
cygheap_fixup_in_child (child_proc_info->parent, 0);
alloc_stack (fork_info);
set_myself (mypid);
- user_data->forkee = child_proc_info->cygpid;
user_data->heaptop = child_proc_info->heaptop;
user_data->heapbase = child_proc_info->heapbase;
user_data->heapptr = child_proc_info->heapptr;
ProtectHandle (child_proc_info->forker_finished);
break;
- case PROC_EXEC:
case PROC_SPAWN:
+ CloseHandle (spawn_info->hexec_proc);
+ goto around;
+ case PROC_EXEC:
+ hexec_proc = spawn_info->hexec_proc;
+ around:
HANDLE h;
cygheap_fixup_in_child (spawn_info->parent, 1);
if (!spawn_info->moreinfo->myself_pinfo ||
set_myself (mypid, h);
__argc = spawn_info->moreinfo->argc;
__argv = spawn_info->moreinfo->argv;
- envp = spawn_info->moreinfo->environ;
+ envp = spawn_info->moreinfo->envp;
+ envc = spawn_info->moreinfo->envc;
cygcwd.fixup_after_exec (spawn_info->moreinfo->cwd_win32,
spawn_info->moreinfo->cwd_posix,
spawn_info->moreinfo->cwd_hash);
fdtab.fixup_after_exec (spawn_info->parent, spawn_info->moreinfo->nfds,
spawn_info->moreinfo->fds);
+ signal_fixup_after_exec (child_proc_info->type == PROC_SPAWN);
CloseHandle (spawn_info->parent);
if (spawn_info->moreinfo->old_title)
{
cfree (spawn_info->moreinfo->old_title);
}
ProtectHandle (child_proc_info->subproc_ready);
+ myself->uid = spawn_info->moreinfo->uid;
+ if (myself->uid == USHRT_MAX)
+ myself->use_psid = 0;
break;
}
}
instead of each time a file is opened. */
set_process_privileges ();
+ cygbench ("pre-forkee");
+
if (user_data->forkee)
{
/* If we've played with the stack, stacksize != 0. That means that
cygcwd.init ();
/* Initialize our process table entry. */
- pinfo_init (envp);
+ pinfo_init (envp, envc);
if (!old_title && GetConsoleTitle (title_buf, TITLESIZE))
old_title = title_buf;
- /* Nasty static stuff needed by newlib - initialize it.
- Note that impure_ptr has already been set up to point to this above
- NB. This *MUST* be done here, just after the forkee code as some
- of the calls below (eg. uinfo_init) do stdio calls - this area must
- be set to zero before then. */
-
- user_data->threadinterface->ClearReent();
- user_data->threadinterface->Init1();
-
- char *line = GetCommandLineA ();
-
- line = strcpy ((char *) alloca (strlen (line) + 1), line);
-
/* Allocate fdtab */
dtable_init ();
if (!__argc)
{
+ char *line = GetCommandLineA ();
+ line = strcpy ((char *) alloca (strlen (line) + 1), line);
+
/* Scan the command line and build argv. Expand wildcards if not
called from another cygwin process. */
build_argv (line, __argv, __argc,
set_errno (0);
MALLOC_CHECK;
+ cygbench (__progname);
if (user_data->main)
exit (user_data->main (__argc, __argv, *user_data->envptr));
}
_dll_crt0 ()
{
char zeros[sizeof (fork_info->zero)] = {0};
+#ifdef DEBUGGING
+ strace.microseconds ();
+#endif
/* Set the os_being_run global. */
set_os_type ();
{
switch (fork_info->type)
{
- case PROC_EXEC:
- case PROC_SPAWN:
case PROC_FORK:
case PROC_FORK1:
+ user_data->forkee = fork_info->cygpid;
+ case PROC_EXEC:
+ case PROC_SPAWN:
{
child_proc_info = fork_info;
mypid = child_proc_info->cygpid;
}
}
- if ((hExeced && hExeced != INVALID_HANDLE_VALUE) || (n & EXIT_NOCLOSEALL))
- n &= ~EXIT_NOCLOSEALL;
- else if (exit_state < ES_CLOSEALL)
+ if (exit_state < ES_CLOSEALL)
{
exit_state = ES_CLOSEALL;
close_all_files ();
/* Kill orphaned children on group leader exit */
if (myself->pid == myself->pgid)
{
+ system_printf ("%d == pgrp %d, send SIG{HUP,CONT} to stopped children",
+ myself->pid, myself->pgid);
sigproc_printf ("%d == pgrp %d, send SIG{HUP,CONT} to stopped children",
myself->pid, myself->pgid);
kill_pgrp (myself->pgid, -SIGHUP);
}
window_terminate ();
- fill_rusage (&myself->rusage_self, hMainProc);
-
events_terminate ();
-
- if (hExeced && hExeced != INVALID_HANDLE_VALUE)
- {
- debug_printf ("Killing(%d) non-cygwin process, handle %p", n, hExeced);
- TerminateProcess (hExeced, n);
- ForceCloseHandle1 (hExeced, childhProc);
- }
-
shared_terminate ();
minimal_printf ("winpid %d, exit %d", GetCurrentProcessId (), n);
myself->exit (1);
}
+#ifdef DEBUGGING
+void __stdcall
+cygbench (const char *s)
+{
+ char buf[1024];
+ if (GetEnvironmentVariable ("CYGWIN_BENCH", buf, sizeof (buf)))
+ small_printf ("%05d ***** %s : %10d\n", GetCurrentProcessId (), s, strace.microseconds ());
+}
+#endif
+
extern "C" {
/* This struct is unused, but it illustrates the layout of a DLL
#endif
extern "C" {
-#ifndef DEBUGGING0
-DWORD __stdcall WFSO (HANDLE, DWORD);
-DWORD __stdcall WFMO (DWORD, CONST HANDLE *, BOOL, DWORD);
-#else
-DWORD __stdcall WFSO (const char *fn, int ln, HANDLE, DWORD);
-DWORD __stdcall WFMO (const char *fn, int ln, DWORD, CONST HANDLE *, BOOL, DWORD);
-#endif
+DWORD __stdcall WFSO (HANDLE, DWORD) __attribute__ ((regparm(2)));
+DWORD __stdcall WFMO (DWORD, CONST HANDLE *, BOOL, DWORD) __attribute__ ((regparm(3)));
}
-#ifndef DEBUGGING0
#define WaitForSingleObject WFSO
#define WaitForMultipleObject WFMO
-#else
-#define WaitForSingleObject(a, b) WFSO (__FUNCTION__, __LINE__, a, b)
-#define WaitForMultipleObject(a, b, c, d) WFMO (__FUNCTION__, __LINE__, a, b, c, d)
-#endif
#if !defined(_DEBUG_H_)
#define _DEBUG_H_
int __stdcall iscygthread ();
#ifndef DEBUGGING
+# define cygbench(s)
# define ForceCloseHandle CloseHandle
# define ForceCloseHandle1(h, n) CloseHandle (h)
# define ForceCloseHandle2(h, n) CloseHandle (h)
void __stdcall add_handle (const char *, int, HANDLE, const char *);
BOOL __stdcall close_handle (const char *, int, HANDLE, const char *, BOOL);
int __stdcall lpfu (const char *, int, DWORD timeout);
+void __stdcall cygbench (const char *s);
#endif /*DEBUGGING*/
#endif /*_DEBUG_H_*/
#include "fhandler.h"
#include "path.h"
#include "dtable.h"
-#include "thread.h"
dtable fdtab;
{
if (!not_open (fd))
{
- delete fds[fd]; /* CGF FIXME */
+ delete fds[fd];
fds[fd] = NULL;
}
}
fhandler_base *build_fhandler (int fd, DWORD dev, const char *name,
int unit = -1);
fhandler_base *build_fhandler (int fd, const char *name, HANDLE h);
- int not_open (int n);
+ int not_open (int n) __attribute__ ((regparm(1)));
int find_unused_handle (int start);
int find_unused_handle () { return find_unused_handle (first_fd_for_open);}
void release (int fd);
void init_std_file_from_handle (int fd, HANDLE handle, DWORD access, const char *name);
int dup2 (int oldfd, int newfd);
void fixup_after_exec (HANDLE, size_t, fhandler_base **);
- fhandler_base *operator [](int fd) { return fds[fd]; }
+ inline fhandler_base *operator [](int fd) { return fds[fd]; }
select_record *select_read (int fd, select_record *s);
select_record *select_write (int fd, select_record *s);
select_record *select_except (int fd, select_record *s);
* environment variable and set appropriate options from it.
*/
void
-environ_init (char **envp)
+environ_init (char **envp, int envc)
{
char *rawenv;
- int sz, i;
+ int i;
char *p;
char *newp;
int sawTERM = 0;
envp_passed_in = 0;
else
{
- sz = envsize (envp, 1);
- char **newenv = (char **) malloc (sz);
- memcpy (newenv, envp, sz);
+ char **newenv = (char **) malloc (envc);
+ memcpy (newenv, envp, envc);
cfree (envp);
envp = newenv;
envp_passed_in = 1;
}
/* Allocate space for environment + trailing NULL + CYGWIN env. */
- lastenviron = envp = (char **) malloc ((4 + (sz = 100)) * sizeof (char *));
+ lastenviron = envp = (char **) malloc ((4 + (envc = 100)) * sizeof (char *));
rawenv = GetEnvironmentStrings ();
/* Current directory information is recorded as variables of the
for (i = 0, p = rawenv; *p != '\0'; p = strchr (p, '\0') + 1, i++)
{
newp = strdup (p);
- if (i >= sz)
- envp = (char **) realloc (envp, (4 + (sz += 100)) *
- sizeof (char *));
+ if (i >= envc)
+ envp = (char **) realloc (envp, (4 + (envc += 100)) * sizeof (char *));
envp[i] = newp;
if (*newp == '=')
*newp = '!';
details. */
/* Initialize the environment */
-void environ_init (char **);
+void environ_init (char **, int);
/* The structure below is used to control conversion to/from posix-style
* file specs. Currently, only PATH and HOME are converted, but PATH
#include "sigproc.h"
#include "pinfo.h"
#include "cygerrno.h"
-#include "thread.h"
#include "perthread.h"
#include "shared_info.h"
#include "perprocess.h"
SetThreadContext (myself->getthread2signal (), ctx); /* Restart the thread */
}
-void __cdecl
+void __stdcall
signal_fixup_after_fork ()
{
if (!sigsave.sig)
}
}
+void __stdcall
+signal_fixup_after_exec (bool isspawn)
+{
+ /* Set up child's signal handlers */
+ for (int i = 0; i < NSIG; i++)
+ {
+ myself->getsig(i).sa_mask = 0;
+ if (myself->getsig(i).sa_handler != SIG_IGN || isspawn)
+ myself->getsig(i).sa_handler = SIG_DFL;
+ }
+}
+
static int
interrupt_on_return (DWORD ebp, int sig, struct sigaction& siga, void *handler)
{
}
next:
- if (hExeced != NULL || (!using_mainthread_frame && interruptible (cx.Eip)))
+ if (!using_mainthread_frame && interruptible (cx.Eip))
interrupt_now (&cx, sig, siga, handler);
else if (!interrupt_on_return (ebp, sig, siga, handler))
{
}
/* Scan buffer and turn \r\n into \n */
- register char *src= (char *) ptr;
+ register char *src = (char *) ptr;
register char *dst = (char *) ptr;
register char *end = src + copied_chars - 1;
* \\server\share... -> \\server\share\
* else current drive.
*/
- char *root=full_path;
+ char *root = full_path;
if (full_path[1] == ':')
strcpy (full_path + 2, "\\");
/* Initialize signal/process handling */
sigproc_init ();
+ cygbench ("fork-child");
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
-#include "thread.h"
#include "sync.h"
#include "sigproc.h"
#include "pinfo.h"
class strace
{
- int microseconds ();
int vsprntf (char *buf, const char *func, const char *infmt, va_list ap);
void write (unsigned category, const char *buf, int count);
public:
+ int microseconds ();
int version;
int active;
int lmicrosec;
#include "fhandler.h"
#include "dtable.h"
#include "cygerrno.h"
-#include "thread.h"
#include "sync.h"
#include "sigproc.h"
#include "pinfo.h"
#include "fhandler.h"
#include "path.h"
#include "dtable.h"
-#include "thread.h"
#include "sync.h"
#include "sigproc.h"
#include "pinfo.h"
#include "cygerrno.h"
#include "fhandler.h"
#include "dtable.h"
-#include "thread.h"
#include "sync.h"
#include "sigproc.h"
#include "pinfo.h"
#include "cygerrno.h"
#include "fhandler.h"
#include "path.h"
-#include "thread.h"
#include "sync.h"
#include "sigproc.h"
#include "pinfo.h"
}
if (!isslash (src[0]))
{
- char cwd[MAX_PATH];
- if (!cygcwd.get (cwd))
+ if (!cygcwd.get (dst))
return get_errno ();
- if (strlen (cwd) + 1 + strlen (src) >= MAX_PATH)
+ if (strlen (dst) + 1 + strlen (src) >= MAX_PATH)
{
debug_printf ("ENAMETOOLONG = normalize_posix_path (%s)", src);
return ENAMETOOLONG;
}
- strcpy (dst, cwd);
dst = strchr (dst, '\0');
if (*src == '.')
goto sawdot;
if (!SLASH_P (src[0]) && strchr (src, ':') == NULL)
{
- char cwd[MAX_PATH];
- if (!cygcwd.get (cwd, 0))
+ if (!cygcwd.get (dst, 0))
return get_errno ();
- if (strlen (cwd) + 1 + strlen (src) >= MAX_PATH)
+ if (strlen (dst) + 1 + strlen (src) >= MAX_PATH)
{
debug_printf ("ENAMETOOLONG = normalize_win32_path (%s)", src);
return ENAMETOOLONG;
}
- strcpy (dst, cwd);
dst += strlen (dst);
- if (!*cwd || !SLASH_P (dst[-1]))
+ if (!SLASH_P (dst[-1]))
*dst++ = '\\';
}
/* Two leading \'s? If so, preserve them. */
})
/* Return TRUE if two strings match up to length n */
-int __stdcall
+extern "C" int __stdcall
strncasematch (const char *s1, const char *s2, size_t n)
{
if (s1 == s2)
}
/* Return TRUE if two strings match */
-int __stdcall
+extern "C" int __stdcall
strcasematch (const char *s1, const char *s2)
{
if (s1 == s2)
return *s2 == '\0';
}
-char * __stdcall
+extern "C" char * __stdcall
strcasestr (const char *searchee, const char *lookfor)
{
if (*searchee == 0)
bool
cwdstuff::get_initial ()
{
+ lock->acquire ();
+
if (win32)
return 1;
- lock->acquire ();
int i;
DWORD len, dlen;
for (i = 0, dlen = MAX_PATH, len = 0; i < 3; dlen *= 2, i++)
__seterrno ();
lock->release ();
debug_printf ("get_initial_cwd failed, %E");
+ lock->release ();
return 0;
}
set (NULL);
#include "fhandler.h"
#include "dtable.h"
#include "cygerrno.h"
-#include "thread.h"
#include "sync.h"
#include "sigproc.h"
#include "pinfo.h"
pinfo NO_COPY myself ((_pinfo *)&pinfo_dummy); // Avoid myself != NULL checks
-static HANDLE hexec_proc = NULL;
+HANDLE hexec_proc = NULL;
void __stdcall
pinfo_fixup_after_fork ()
}
}
-void __stdcall
-pinfo_fixup_in_spawned_child (HANDLE hchild)
-{
- HANDLE h;
- if (!hexec_proc)
- return;
- if (!DuplicateHandle (hchild, hexec_proc, hMainProc, &h, 0, TRUE,
- DUPLICATE_CLOSE_SOURCE))
- system_printf ("couldn't close handle %p in child, %E", hexec_proc);
- else
- CloseHandle (h);
-}
-
/* Initialize the process table.
This is done once when the dll is first loaded. */
/* Initialize the process table entry for the current task.
This is not called for fork'd tasks, only exec'd ones. */
void __stdcall
-pinfo_init (char **envp)
+pinfo_init (char **envp, int envc)
{
if (envp)
{
- environ_init (envp);
+ environ_init (envp, envc);
/* spawn has already set up a pid structure for us so we'll use that */
myself->process_state |= PID_CYGPARENT;
}
myself->ctty = -1;
myself->uid = USHRT_MAX;
- environ_init (NULL); /* call after myself has been set up */
+ environ_init (NULL, 0); /* call after myself has been set up */
}
debug_printf ("pid %d, pgid %d", myself->pid, myself->pgid);
}
void
-_pinfo::exit (UINT n)
+_pinfo::exit (UINT n, bool norecord)
{
- process_state = PID_EXITED;
- sigproc_printf ("Calling ExitProcess %d", n);
- ExitProcess (n);
-}
+ if (!norecord)
+ process_state = PID_EXITED;
-struct sigaction&
-_pinfo::getsig(int sig)
-{
-#ifdef _MT_SAFE
- if (thread2signal)
- return thread2signal->sigs[sig];
- return sigs[sig];
-#else
- return sigs[sig];
-#endif
-};
-
-sigset_t&
-_pinfo::getsigmask ()
-{
-#ifdef _MT_SAFE
- if (thread2signal)
- return *thread2signal->sigmask;
- return sig_mask;
-#else
- return sig_mask;
-#endif
-};
-
-void
-_pinfo::setsigmask (sigset_t _mask)
-{
-#ifdef _MT_SAFE
- if (thread2signal)
- *(thread2signal->sigmask) = _mask;
- sig_mask=_mask;
-#else
- sig_mask=_mask;
-#endif
-}
+ /* FIXME: There is a potential race between an execed process and its
+ parent here. I hated to add a mutex just for this, though. */
+ struct rusage r;
+ fill_rusage (&r, hMainProc);
+ add_rusage (&rusage_self, &r);
-LONG *
-_pinfo::getsigtodo(int sig)
-{
-#ifdef _MT_SAFE
- if (thread2signal)
- return thread2signal->sigtodo + __SIGOFFSET + sig;
- return _sigtodo + __SIGOFFSET + sig;
-#else
- return _sigtodo + __SIGOFFSET + sig;
-#endif
-}
-
-extern HANDLE hMainThread;
-
-HANDLE
-_pinfo::getthread2signal()
-{
-#ifdef _MT_SAFE
- if (thread2signal)
- return thread2signal->win32_obj_id;
- return hMainThread;
-#else
- return hMainThread;
-#endif
-}
-
-void
-_pinfo::setthread2signal(void *_thr)
-{
-#ifdef _MT_SAFE
- // assert has myself lock
- thread2signal=(ThreadItem*)_thr;
-#else
-#endif
-}
-
-void
-_pinfo::copysigs(_pinfo *_other)
-{
- sigs = _other->sigs;
+ sigproc_printf ("Calling ExitProcess %d", n);
+ ExitProcess (n);
}
void
#define PSIZE 1024
-class ThreadItem;
#include <sys/resource.h>
+#include "thread.h"
class _pinfo
{
/* Non-zero if process was stopped by a signal. */
char stopsig;
- struct sigaction& getsig (int);
- void copysigs (_pinfo* );
- sigset_t& getsigmask ();
- void setsigmask (sigset_t);
- LONG* getsigtodo (int);
- HANDLE getthread2signal ();
- void setthread2signal (void *);
- void exit (UINT n) __attribute__ ((noreturn));
+ void exit (UINT n, bool norecord = 0) __attribute__ ((noreturn, regparm(2)));
+
+ inline struct sigaction& getsig (int sig)
+ {
+ return thread2signal ? thread2signal->sigs[sig] : sigs[sig];
+ }
+
+ inline void copysigs (_pinfo *p) {sigs = p->sigs;}
+
+ inline sigset_t& getsigmask ()
+ {
+ return thread2signal ? *thread2signal->sigmask : sig_mask;
+ }
+
+ inline void setsigmask (sigset_t mask)
+ {
+ if (thread2signal)
+ *(thread2signal->sigmask) = mask;
+ sig_mask = mask;
+ }
+
+ inline LONG* getsigtodo (int sig) {return _sigtodo + __SIGOFFSET + sig;}
+
+ inline HANDLE getthread2signal ()
+ {
+ return thread2signal ? thread2signal->win32_obj_id : hMainThread;
+ }
+
+ inline void setthread2signal (void *thr) {thread2signal = (ThreadItem *) thr;}
private:
struct sigaction sigs[NSIG];
sigset_t sig_mask; /* one set for everything to ignore. */
LONG _sigtodo[NSIG + __SIGOFFSET];
- ThreadItem* thread2signal; // NULL means means thread any other means a pthread
+ ThreadItem *thread2signal; // NULL means means thread any other means a pthread
};
class pinfo
return (pid_t) (os_being_run == winNT) ? pid : -(int) pid;
}
-void __stdcall pinfo_init (char **);
+void __stdcall pinfo_init (char **, int);
void __stdcall set_myself (pid_t pid, HANDLE h = NULL);
extern pinfo myself;
const char *const *argv, const char *const *envp);
extern void __stdcall pinfo_fixup_after_fork ();
-extern void __stdcall pinfo_fixup_in_spawned_child (HANDLE hchild);
+extern HANDLE hexec_proc;
/* For mmaps across fork(). */
int __stdcall recreate_mmaps_after_fork (void *);
pchildren[i].release ();
}
nchildren = nzombies = 0;
-
/* Just zero sync_proc_subproc as the delete below seems to cause
problems for older gccs. */
- #if 1
sync_proc_subproc = NULL;
- #else
- /* Attempt to close and release sync_proc_subproc in a
- * non-raceable manner.
- */
- muto *m = sync_proc_subproc;
- if (m)
- {
- sync_proc_subproc = NULL;
- // delete m;
- }
- #endif
}
sigproc_printf ("leaving");
}
BOOL __stdcall pid_exists (pid_t);
int __stdcall sig_send (_pinfo *, int, DWORD ebp = (DWORD) __builtin_frame_address (0));
void __stdcall signal_fixup_after_fork ();
+void __stdcall signal_fixup_after_exec (bool);
extern char myself_nowait_dummy[];
extern char myself_nowait_nonmain_dummy[];
-extern HANDLE hExeced; // Process handle of new window
- // process created by spawn_guts()
#define WAIT_SIG_EXITING (WAIT_OBJECT_0 + 1)
return fh->get_output_handle ();
}
-HANDLE NO_COPY hExeced = NULL;
-
int
iscmd (const char *argv0, const char *what)
{
spawn_guts (HANDLE hToken, const char * prog_arg, const char *const *argv,
const char *const envp[], int mode)
{
- int i;
BOOL rc;
pid_t cygpid;
- hExeced = NULL;
-
MALLOC_CHECK;
if (prog_arg == NULL)
cygcwd.copy (ciresrv.moreinfo->cwd_posix, ciresrv.moreinfo->cwd_win32,
ciresrv.moreinfo->cwd_hash);
- ciresrv.moreinfo->environ = (char **) cmalloc (HEAP_1_ARGV, envsize (envp, 1));
+ ciresrv.moreinfo->envc = envsize (envp, 0);
+ ciresrv.moreinfo->envp = (char **) cmalloc (HEAP_1_ARGV, ciresrv.moreinfo->envc);
+ ciresrv.hexec_proc = hexec_proc;
char **c;
const char * const *e;
- for (c = ciresrv.moreinfo->environ, e = envp; *e;)
+ for (c = ciresrv.moreinfo->envp, e = envp; *e;)
*c++ = cstrdup1 (*e++);
*c = NULL;
if (mode != _P_OVERLAY ||
syscall_printf ("spawn_guts (%s, %.132s)", (char *) real_path, one_line.buf);
- int flags = CREATE_DEFAULT_ERROR_MODE | CREATE_SUSPENDED |
- GetPriorityClass (hMainProc);
+ int flags = CREATE_DEFAULT_ERROR_MODE | GetPriorityClass (hMainProc);
if (mode == _P_DETACH || !set_console_state_for_spawn ())
flags |= DETACHED_PROCESS;
+ if (mode != _P_OVERLAY)
+ flags |= CREATE_SUSPENDED;
/* Build windows style environment list */
char *envblock;
if (!hToken && myself->token != INVALID_HANDLE_VALUE)
hToken = myself->token;
- if (hToken)
+cygbench ("spawn-guts");
+ if (!hToken)
+ {
+ ciresrv.moreinfo->uid = getuid ();
+ rc = CreateProcess (real_path, /* image name - with full path */
+ one_line.buf, /* what was passed to exec */
+ /* process security attrs */
+ allow_ntsec ? sec_user (sa_buf) : &sec_all_nih,
+ /* thread security attrs */
+ allow_ntsec ? sec_user (sa_buf) : &sec_all_nih,
+ TRUE, /* inherit handles from parent */
+ flags,
+ envblock,/* environment */
+ 0, /* use current drive/directory */
+ &si,
+ &pi);
+ }
+ else
{
/* allow the child to interact with our window station/desktop */
HANDLE hwst, hdsk;
char wstname[1024];
char dskname[1024];
+ ciresrv.moreinfo->uid = USHRT_MAX;
hwst = GetProcessWindowStation();
SetUserObjectSecurity(hwst, &dsi, get_null_sd ());
GetUserObjectInformation(hwst, UOI_NAME, wstname, 1024, &n);
&& myself->impersonated && myself->token != INVALID_HANDLE_VALUE)
seteuid (uid);
}
- else
- rc = CreateProcess (real_path, /* image name - with full path */
- one_line.buf, /* what was passed to exec */
- /* process security attrs */
- allow_ntsec ? sec_user (sa_buf) : &sec_all_nih,
- /* thread security attrs */
- allow_ntsec ? sec_user (sa_buf) : &sec_all_nih,
- TRUE, /* inherit handles from parent */
- flags,
- envblock,/* environment */
- 0, /* use current drive/directory */
- &si,
- &pi);
MALLOC_CHECK;
if (envblock)
/* Name the handle similarly to proc_subproc. */
ProtectHandle1 (pi.hProcess, childhProc);
- ProtectHandle (pi.hThread);
if (mode == _P_OVERLAY)
{
+ /* These are both duplicated in the child code. We do this here,
+ primarily for strace. */
strcpy (myself->progname, real_path);
- hExeced = pi.hProcess;
myself->dwProcessId = pi.dwProcessId;
-
- /* Set up child's signal handlers */
- /* CGF FIXME - consolidate with signal stuff below */
- for (i = 0; i < NSIG; i++)
- {
- myself->getsig(i).sa_mask = 0;
- if (myself->getsig(i).sa_handler != SIG_IGN || (mode != _P_OVERLAY))
- myself->getsig(i).sa_handler = SIG_DFL;
- }
}
else
{
- pinfo_fixup_in_spawned_child (pi.hProcess);
+ ProtectHandle (pi.hThread);
pinfo child (cygpid, 1);
if (!child)
{
child->username[0] = '\0';
child->progname[0] = '\0';
child->ppid = myself->pid;
- child->uid = myself->uid;
child->gid = myself->gid;
child->pgid = myself->pgid;
child->sid = myself->sid;
child->rootlen = myself->rootlen;
child->dwProcessId = pi.dwProcessId;
child->hProcess = pi.hProcess;
- for (i = 0; i < NSIG; i++)
- {
- child->getsig(i).sa_mask = 0;
- if (child->getsig(i).sa_handler != SIG_IGN || (mode != _P_OVERLAY))
- child->getsig(i).sa_handler = SIG_DFL;
- }
- if (hToken)
- {
- /* Set child->uid to USHRT_MAX to force calling internal_getlogin()
- from child process. Clear username and psid to play it safe. */
- child->uid = USHRT_MAX;
- child->use_psid = 0;
- }
child.remember ();
+ /* Start the child running */
+ ResumeThread (pi.hThread);
}
- sigproc_printf ("spawned windows pid %d", pi.dwProcessId);
- /* Start the child running */
- ResumeThread (pi.hThread);
ForceCloseHandle (pi.hThread);
+ sigproc_printf ("spawned windows pid %d", pi.dwProcessId);
+
if (hToken && hToken != myself->token)
CloseHandle (hToken);
system_printf ("old hProcess %p, hProcess %p", oldh, myself->hProcess);
}
}
- if (hExeced)
- {
- ForceCloseHandle1 (hExeced, childhProc);
- hExeced = INVALID_HANDLE_VALUE;
- }
- }
- else if (exited)
- {
- ForceCloseHandle1 (hExeced, childhProc);
- hExeced = INVALID_HANDLE_VALUE; // stop do_exit from attempting to terminate child
}
MALLOC_CHECK;
switch (mode)
{
case _P_OVERLAY:
+ ForceCloseHandle1 (pi.hProcess, childhProc);
proc_terminate ();
- struct rusage r;
- fill_rusage (&r, hMainProc);
- add_rusage (&myself->rusage_self, &r);
- ExitProcess (0);
+ myself->exit (0, 1);
break;
case _P_WAIT:
waitpid (cygpid, (int *) &res, 0);
*p = '\000';
p = progname;
count = __small_sprintf (buf, fmt, p && *p ? p : "?",
- myself->pid, hExeced ? "!" : "");
+ myself->pid,
+ myself->dwProcessId != GetCurrentProcessId ()
+ ? "!" : "");
if (func)
count += getfunc (buf + count, func);
}
#include "fhandler.h"
#include "path.h"
#include "dtable.h"
-#include "thread.h"
#include "sync.h"
#include "sigproc.h"
#include "pinfo.h"
#include <assert.h>
#include <stdlib.h>
#include <syslog.h>
-#include "thread.h"
#include "sync.h"
#include "sigproc.h"
#include "pinfo.h"
SetLastError (tmp);
return _r->_clib;
-};
+}
struct _winsup_t *
_reent_winsup ()
#endif
SetLastError (tmp);
return _r->_winsup;
-};
+}
inline LPCRITICAL_SECTION
ResourceLocks::Lock (int _resid)
_resid, &lock, user_data, myself->pid, GetCurrentThreadId ());
#endif
return &lock;
-};
+}
void
SetResourceLock (int _res_id, int _mode, const char *_function)
#endif
LeaveCriticalSection (user_data->resourcelocks->Lock (_res_id));
-};
+}
#ifdef _CYG_THREAD_FAILSAFE
void
void
ResourceLocks::Init ()
{
- thread_printf ("Init resource lock %p -> %p", this, &lock);
-
InitializeCriticalSection (&lock);
inited = true;
count = 0;
#endif
- thread_printf ("Resource lock %p inited by %p , %d", &lock, user_data, myself->pid);
-};
+ thread_printf ("lock %p inited by %p , %d", &lock, user_data, myself->pid);
+}
void
ResourceLocks::Delete ()
DeleteCriticalSection (&lock);
inited = false;
}
-};
+}
// Thread interface
MTinterface::ReleaseItem (MTitem * _item)
{
_item->used = false;
-};
+}
MTitem *
MTinterface::Find (void *_value, int (*comp) (void *, void *), register int &_index, MTList * _list)
current = NULL;
}
return current;
-};
+}
int
MTinterface::Find (MTitem & _item, MTList * _list)
break;
}
return (_index == _list->index ? -1 : _index);
-};
+}
int
MTinterface::FindNextUnused (MTList * _list)
{
register int i = 0;
- for (; i < _list->index && _list->items[i] != NULL && _list->items[i]->used && _list->items[i]->joinable != 'Y'; i++);
+ for (; i < _list->index && _list->items[i] != NULL && _list->items[i]->used && _list->items[i]->joinable != 'Y'; i++)
+ continue;
return i;
-};
+}
MTitem *
MTinterface::GetItem (int _index, MTList * _list)
{
return (_index < _list->index ? _list->items[_index] : NULL);
-};
+}
MTitem *
MTinterface::SetItem (int _index, MTitem * _item, MTList * _list)
if (_index == _list->index && _list->index < MT_MAX_ITEMS)
_list->index++;
return (_index < _list->index ? _list->items[_index] = _item : NULL);
-};
+}
int
CmpPthreadObj (void *_i, void *_value)
{
return ((MTitem *) _i)->Id () == *(int *) _value;
-};
+}
int
CmpThreadId (void *_i, void *_id)
{
return ((ThreadItem *) _i)->thread_id == * (DWORD *) _id;
-};
+}
void
-MTinterface::Init0 ()
+MTinterface::Init (int forked)
{
+#if 0
for (int i = 0; i < MT_MAX_ITEMS; i++)
{
threadlist.items[i] = NULL;
threadlist.index = 0;
mutexlist.index = 0;
semalist.index = 0;
+#endif
reent_index = TlsAlloc ();
reents._winsup = &winsup_reent;
winsup_reent._process_logmask = LOG_UPTO (LOG_DEBUG);
+#if 0
winsup_reent._grp_pos = 0;
winsup_reent._process_ident = 0;
winsup_reent._process_logopt = 0;
winsup_reent._process_facility = 0;
+#endif
TlsSetValue (reent_index, &reents);
// the static reent_data will be used in the main thread
-};
+ if (forked)
+ return;
-void
-MTinterface::Init1 ()
-{
// create entry for main thread
- int i = FindNextUnused (&threadlist);
- assert (i == 0);
- ThreadItem *item = (ThreadItem *) GetItem (i, &threadlist);
+ ThreadItem *item = (ThreadItem *) GetItem (0, &threadlist);
- item = (ThreadItem *) SetItem (i, &mainthread, &threadlist);
+ item = (ThreadItem *) SetItem (0, &mainthread, &threadlist);
item->used = true;
item->win32_obj_id = myself->hProcess;
item->thread_id = GetCurrentThreadId ();
+#if 0
item->function = NULL;
item->sigs = NULL;
item->sigmask = NULL;
item->sigtodo = NULL;
-};
+#endif
-void
-MTinterface::ClearReent ()
-{
struct _reent *r = _REENT;
memset (r, 0, sizeof (struct _reent));
r->_stdin = &r->__sf[0];
r->_stdout = &r->__sf[1];
r->_stderr = &r->__sf[2];
-
-};
-
+}
ThreadItem *
MTinterface::CreateThread (pthread_t * t, TFD (func), void *arg, pthread_attr_t a)
*t = (pthread_t) item->win32_obj_id;
return item;
-};
-
+}
MutexItem *
MTinterface::CreateMutex (pthread_mutex_t * mutex)
DWORD id = GetCurrentThreadId ();
int index = 0;
return (ThreadItem *) Find (&id, &CmpThreadId, index, &threadlist);
-};
+}
ThreadItem *
MTinterface::GetThread (pthread_t * _t)
AssertResourceOwner (LOCK_THREAD_LIST, READ_LOCK);
int index = 0;
return (ThreadItem *) Find (_t, &CmpPthreadObj, index, &threadlist);
-};
+}
MutexItem *
MTinterface::GetMutex (pthread_mutex_t * mp)
MTitem::Destroy ()
{
CloseHandle (win32_obj_id);
-};
+}
int
MutexItem::Lock ()
{
return WaitForSingleObject (win32_obj_id, INFINITE);
-};
+}
int
MutexItem::TryLock ()
{
return WaitForSingleObject (win32_obj_id, 0);
-};
+}
int
MutexItem::UnLock ()
*_s = (sem_t) item->win32_obj_id;
return item;
-};
+}
int
SemaphoreItem::Wait ()
{
return WaitForSingleObject (win32_obj_id, INFINITE);
-};
+}
int
SemaphoreItem::Post ()
{
long pc;
return ReleaseSemaphore (win32_obj_id, 1, &pc);
-};
+}
int
SemaphoreItem::TryWait ()
{
return WaitForSingleObject (win32_obj_id, 0);
-};
+}
////////////////////////// Pthreads
ReleaseResourceLock (LOCK_THREAD_LIST, WRITE_LOCK | READ_LOCK, "__pthread_create");
return 0;
-};
+}
int
__pthread_attr_init (pthread_attr_t * attr)
{
attr->stacksize = 0;
return 0;
-};
+}
int
__pthread_attr_setstacksize (pthread_attr_t * attr, size_t size)
{
attr->stacksize = size;
return 0;
-};
+}
int
__pthread_attr_getstacksize (pthread_attr_t * attr, size_t * size)
{
*size = attr->stacksize;
return 0;
-};
+}
int
__pthread_attr_destroy (pthread_attr_t * /*attr*/)
{
return 0;
-};
+}
int
__pthread_exit (void *value_ptr)
}/* End if*/
return 0;
-};
+}
int
__pthread_detach (pthread_t * thread)
{
GETTHREAD ("__pthread_getsequence_np");
return item->GetThreadId ();
-};
+}
/* Thread SpecificData */
int
__pthread_key_create (pthread_key_t */*key*/)
{
NOT_IMP ("_p_key_create\n");
-};
+}
int
__pthread_key_delete (pthread_key_t */*key*/)
{
NOT_IMP ("_p_key_delete\n");
-};
+}
int
__pthread_setspecific (pthread_key_t */*key*/, const void */*value*/)
{
NOT_IMP ("_p_key_setsp\n");
-};
+}
void *
__pthread_getspecific (pthread_key_t */*key*/)
{
NOT_IMP ("_p_key_getsp\n");
-};
+}
/* Thread signal */
int
// unlock myself
return rval;
-};
+}
int
__pthread_sigmask (int operation, const sigset_t * set, sigset_t * old_set)
// unlock this myself
return rval;
-};
+}
/* ID */
pthread_t
ReleaseResourceLock (LOCK_THREAD_LIST, READ_LOCK, "__pthread_self");
return (pthread_t) item->Id ();
-};
+}
int
__pthread_equal (pthread_t * t1, pthread_t * t2)
{
return (*t1 - *t2);
-};
+}
/* Mutexes */
ReleaseResourceLock (LOCK_MUTEX_LIST, WRITE_LOCK | READ_LOCK, "__pthread_mutex_init");
return 0;
-};
+}
int
__pthread_mutex_lock (pthread_mutex_t * mutex)
item->Lock ();
return 0;
-};
+}
int
__pthread_mutex_trylock (pthread_mutex_t * mutex)
return EBUSY;
return 0;
-};
+}
int
__pthread_mutex_unlock (pthread_mutex_t * mutex)
item->UnLock ();
return 0;
-};
+}
int
__pthread_mutex_destroy (pthread_mutex_t * mutex)
ReleaseResourceLock (LOCK_MUTEX_LIST, READ_LOCK | WRITE_LOCK, "__pthread_mutex_destroy");
return 0;
-};
+}
/* Semaphores */
int
ReleaseResourceLock (LOCK_SEM_LIST, READ_LOCK | WRITE_LOCK, "__sem_init");
return 0;
-};
+}
int
__sem_destroy (sem_t * sem)
ReleaseResourceLock (LOCK_SEM_LIST, READ_LOCK | WRITE_LOCK, "__sem_destroy");
return 0;
-};
+}
int
__sem_wait (sem_t * sem)
item->Wait ();
return 0;
-};
+}
int
__sem_trywait (sem_t * sem)
return EAGAIN;
return 0;
-};
+}
int
__sem_post (sem_t * sem)
item->Post ();
return 0;
-};
+}
#else
_reent *_reent_clib ();
_winsup_t *_reent_winsup ();
-void SetResourceLock (int, int, const char *);
-void ReleaseResourceLock (int, int, const char *);
+void SetResourceLock (int, int, const char *) __attribute__ ((regparm(3)));
+void ReleaseResourceLock (int, int, const char *) __attribute__ ((regparm(3)));
#ifdef _CYG_THREAD_FAILSAFE
void AssertResourceOwner (int, int);
struct _winsup_t winsup_reent;
ThreadItem mainthread;
- void Init0 ();
- void Init1 ();
- void ClearReent ();
+ void Init (int);
void ReleaseItem (MTitem *);
#include "cygerrno.h"
#include "fhandler.h"
#include "path.h"
-#include "thread.h"
#include "sync.h"
#include "sigproc.h"
#include "pinfo.h"
#include <stdlib.h>
#include <wchar.h>
#include <lm.h>
-#include "thread.h"
#include "sync.h"
#include "sigproc.h"
#include "pinfo.h"
int __stdcall stat_dev (DWORD, int, unsigned long, struct stat *);
extern BOOL allow_ntsec;
-unsigned long __stdcall hash_path_name (unsigned long hash, const char *name);
-void __stdcall nofinalslash (const char *src, char *dst);
-extern "C" char *__stdcall rootdir (char *full_path);
+unsigned long __stdcall hash_path_name (unsigned long hash, const char *name) __attribute__ ((regparm(2)));
+void __stdcall nofinalslash (const char *src, char *dst) __attribute__ ((regparm(2)));
+extern "C" char *__stdcall rootdir (char *full_path) __attribute__ ((regparm(1)));
/* String manipulation */
-char *__stdcall strccpy (char *s1, const char **s2, char c);
-int __stdcall strcasematch (const char *s1, const char *s2);
-int __stdcall strncasematch (const char *s1, const char *s2, size_t n);
-char *__stdcall strcasestr (const char *searchee, const char *lookfor);
+extern "C" char *__stdcall strccpy (char *s1, const char **s2, char c);
+extern "C" int __stdcall strcasematch (const char *s1, const char *s2) __attribute__ ((regparm(2)));
+extern "C" int __stdcall strncasematch (const char *s1, const char *s2, size_t n) __attribute__ ((regparm(3)));
+extern "C" char *__stdcall strcasestr (const char *searchee, const char *lookfor) __attribute__ ((regparm(2)));
/* Time related */
void __stdcall totimeval (struct timeval *dst, FILETIME * src, int sub, int flag);
git://sourceware.org / newlib-cygwin.git / commitdiff