From a5a965ff62d95b01858f24d8e89c1dc39bbfb298 Mon Sep 17 00:00:00 2001 From: Christopher Faylor Date: Wed, 2 Aug 2000 03:42:31 +0000 Subject: [PATCH] * strace.h: Add kludgy workarounds to avoid using deprecated methods for variable argument macros when possible. * sigproc.cc: Throughout, use sigproc_printf rather than sip_printf. * strace.cc (strace::prntf): Remove 'active' check, since callers are supposed to ensure this. (__system_printf): Remove. Subsumed by strace::prntf. * winsup.h: Define "NEW_MACRO_VARARGS" to indicate when to use new macro varargs capability. --- winsup/cygwin/ChangeLog | 11 +++ winsup/cygwin/include/sys/strace.h | 48 ++++++++--- winsup/cygwin/sigproc.cc | 128 ++++++++++++++--------------- winsup/cygwin/strace.cc | 66 +++++---------- winsup/cygwin/winsup.h | 13 ++- 5 files changed, 140 insertions(+), 126 deletions(-) diff --git a/winsup/cygwin/ChangeLog b/winsup/cygwin/ChangeLog index 4638a809e..af7fe7214 100644 --- a/winsup/cygwin/ChangeLog +++ b/winsup/cygwin/ChangeLog @@ -1,3 +1,14 @@ +Tue Aug 1 23:37:08 2000 Christopher Faylor + + * strace.h: Add kludgy workarounds to avoid using deprecated methods + for variable argument macros when possible. + * sigproc.cc: Throughout, use sigproc_printf rather than sip_printf. + * strace.cc (strace::prntf): Remove 'active' check, since callers are + supposed to ensure this. + (__system_printf): Remove. Subsumed by strace::prntf. + * winsup.h: Define "NEW_MACRO_VARARGS" to indicate when to use new + macro varargs capability. + Sun Jul 30 13:54:35 2000 Christopher Faylor * fhandler_console.cc: Remove VK_DIVIDE detection. diff --git a/winsup/cygwin/include/sys/strace.h b/winsup/cygwin/include/sys/strace.h index f9db05b02..43aa21c82 100644 --- a/winsup/cygwin/include/sys/strace.h +++ b/winsup/cygwin/include/sys/strace.h @@ -23,7 +23,6 @@ class strace { - friend void __system_printf (const char *fmt, ...); int microseconds (); int vsprntf (char *buf, const char *infmt, va_list ap); void write (unsigned category, const char *buf, int count); @@ -32,10 +31,12 @@ public: int active; int lmicrosec; strace() : version(1) {} - void prntf (unsigned category, const char *fmt,...); + void prntf (unsigned, const char *, ...); void wm (int message, int word, int lon); }; +extern strace strace; + #define _STRACE_INTERFACE_ACTIVATE_ADDR -1 #define _STRACE_INTERFACE_ACTIVATE_ADDR1 -2 @@ -55,7 +56,7 @@ public: #define _STRACE_SIGP 0x00800 // trace signal and process handling #define _STRACE_MINIMAL 0x01000 // very minimal strace output #define _STRACE_EXITDUMP 0x04000 // dump strace cache on exit -#define _STRACE_CACHE 0x08000 // cache strace messages +#define _STRACE_SYSTEM 0x08000 // cache strace messages #define _STRACE_NOMUTEX 0x10000 // don't use mutex for synchronization #define _STRACE_MALLOC 0x20000 // trace malloc calls #define _STRACE_THREAD 0x40000 // thread-locking calls @@ -63,11 +64,35 @@ public: extern "C" void small_printf (const char *, ...); -#ifndef NOSTRACE +#ifdef NOSTRACE +#define define_strace(c, f) +#define define_strace1(c, f) +#else +#ifdef NEW_MACRO_VARARGS /* Output message to strace log */ -#define system_printf(fmt, args...) \ - __system_printf("%F: " fmt, __PRETTY_FUNCTION__ , ## args) +#define define_strace0(c,...) \ + do { \ + if (c & _STRACE_SYSTEM || strace.active) \ + strace.prntf (c, "%F: " __VA_ARGS__); \ + } \ + while (0) + +#define define_strace(c, ...) define_strace0 (_STRACE_ ## c, __VA_ARGS__) +#define define_strace1(c, ...) define_strace0 (_STRACE_ ## c | _STRACE_NOTALL, __VA_ARGS__) + +#define debug_printf(...) define_strace (DEBUG, __VA_ARGS__) +#define paranoid_printf(...) define_strace (PARANOID, __VA_ARGS__) +#define select_printf(...) define_strace (SELECT, __VA_ARGS__) +#define sigproc_printf(...) define_strace (SIGP, __VA_ARGS__) +#define syscall_printf(...) define_strace (SYSCALL, __VA_ARGS__) +#define system_printf(...) define_strace (SYSTEM, __VA_ARGS__) +#define termios_printf(...) define_strace (TERMIOS, __VA_ARGS__) +#define wm_printf(...) define_strace (WM, __VA_ARGS__) +#define minimal_printf(...) define_strace1 (MINIMAL, __VA_ARGS__) +#define malloc_printf(...) define_strace1 (MALLOC, __VA_ARGS__) +#define thread_printf(...) define_strace1 (THREAD, __VA_ARGS__) +#else #define strace_printf_wrap(what, fmt, args...) \ ((void) ({\ if (strace.active) \ @@ -80,17 +105,18 @@ extern "C" void small_printf (const char *, ...); strace.prntf((_STRACE_ ## what) | _STRACE_NOTALL, "%F: " fmt, __PRETTY_FUNCTION__ , ## args); \ 0; \ })) -#endif /*NOSTRACE*/ #define debug_printf(fmt, args...) strace_printf_wrap(DEBUG, fmt , ## args) -#define syscall_printf(fmt, args...) strace_printf_wrap(SYSCALL, fmt , ## args) #define paranoid_printf(fmt, args...) strace_printf_wrap(PARANOID, fmt , ## args) -#define termios_printf(fmt, args...) strace_printf_wrap(TERMIOS, fmt , ## args) #define select_printf(fmt, args...) strace_printf_wrap(SELECT, fmt , ## args) -#define wm_printf(fmt, args...) strace_printf_wrap(WM, fmt , ## args) #define sigproc_printf(fmt, args...) strace_printf_wrap(SIGP, fmt , ## args) +#define syscall_printf(fmt, args...) strace_printf_wrap(SYSCALL, fmt , ## args) +#define system_printf(fmt, args...) strace_printf_wrap(SYSTEM, fmt , ## args) +#define termios_printf(fmt, args...) strace_printf_wrap(TERMIOS, fmt , ## args) +#define wm_printf(fmt, args...) strace_printf_wrap(WM, fmt , ## args) #define minimal_printf(fmt, args...) strace_printf_wrap1(MINIMAL, fmt , ## args) #define malloc_printf(fmt, args...) strace_printf_wrap1(MALLOC, fmt , ## args) #define thread_printf(fmt, args...) strace_printf_wrap1(THREAD, fmt , ## args) - +#endif /*NEW_MACRO_VARARGS*/ +#endif /*NOSTRACE*/ #endif /* _SYS_STRACE_H */ diff --git a/winsup/cygwin/sigproc.cc b/winsup/cygwin/sigproc.cc index 45cc37478..fc7839f80 100644 --- a/winsup/cygwin/sigproc.cc +++ b/winsup/cygwin/sigproc.cc @@ -31,8 +31,6 @@ extern BOOL allow_ntsec; #define TOTSIGS (NSIG + __SIGOFFSET) -#define sip_printf(fmt, args...) sigproc_printf (fmt , ## args) - #define wake_wait_subproc() SetEvent (events[0]) #define no_signals_available() (!hwait_sig || !sig_loop_wait) @@ -205,11 +203,11 @@ proc_exists (_pinfo *p) if (p->process_state == PID_NOT_IN_USE || !p->dwProcessId) return FALSE; - sip_printf ("checking for existence of pid %d, window pid %d", p->pid, + sigproc_printf ("checking for existence of pid %d, window pid %d", p->pid, p->dwProcessId); if (p->ppid == myself->pid && p->hProcess != NULL) { - sip_printf ("it's mine, process_state %x", p->process_state); + sigproc_printf ("it's mine, process_state %x", p->process_state); return proc_can_be_signalled (p); } @@ -217,7 +215,7 @@ proc_exists (_pinfo *p) if (((h = OpenProcess (STANDARD_RIGHTS_REQUIRED, FALSE, p->dwProcessId)) != NULL) || (GetLastError () == ERROR_ACCESS_DENIED)) { - sip_printf ("it exists, %p", h); + sigproc_printf ("it exists, %p", h); if (h) { DWORD rc = WaitForSingleObject (h, 0); @@ -228,7 +226,7 @@ proc_exists (_pinfo *p) return proc_can_be_signalled (p); } - sip_printf ("it doesn't exist"); + sigproc_printf ("it doesn't exist"); /* If the parent pid does not exist, clean this process out of the pinfo * table. It must have died abnormally. */ @@ -255,11 +253,11 @@ proc_subproc (DWORD what, DWORD val) #define wval ((waitq *) val) - sip_printf ("args: %x, %d", what, val); + sigproc_printf ("args: %x, %d", what, val); if (!get_proc_lock (what, val)) // Serialize access to this function { - sip_printf ("I am not ready"); + sigproc_printf ("I am not ready"); goto out1; } @@ -282,7 +280,7 @@ proc_subproc (DWORD what, DWORD val) pchildren[nchildren] = vchild; hchildren[nchildren] = vchild->hProcess; ProtectHandle1 (vchild->hProcess, childhProc); - sip_printf ("added pid %d to wait list, slot %d, winpid %p, handle %p", + sigproc_printf ("added pid %d to wait list, slot %d, winpid %p, handle %p", vchild->pid, nchildren, vchild->dwProcessId, vchild->hProcess); @@ -302,7 +300,7 @@ proc_subproc (DWORD what, DWORD val) if (GetExitCodeProcess (hchildren[val], &exitcode) && hchildren[val] != pchildren[val]->hProcess) { - sip_printf ("pid %d[%d], reparented old hProcess %p, new %p", + sigproc_printf ("pid %d[%d], reparented old hProcess %p, new %p", pchildren[val]->pid, val, hchildren[val], pchildren[val]->hProcess); ForceCloseHandle1 (hchildren[val], childhProc); hchildren[val] = pchildren[val]->hProcess; /* Filled out by child */ @@ -310,7 +308,7 @@ proc_subproc (DWORD what, DWORD val) break; // This was an exec() } - sip_printf ("pid %d[%d] terminated, handle %p, nchildren %d, nzombies %d", + sigproc_printf ("pid %d[%d] terminated, handle %p, nchildren %d, nzombies %d", pchildren[val]->pid, val, hchildren[val], nchildren, nzombies); zombies[nzombies] = pchildren[val]; // Add to zombie array zombies[nzombies++]->process_state = PID_ZOMBIE;// Walking dead @@ -327,7 +325,7 @@ proc_subproc (DWORD what, DWORD val) */ case PROC_CHILDSTOPPED: child = myself; // Just to avoid accidental NULL dereference - sip_printf ("Received stopped notification"); + sigproc_printf ("Received stopped notification"); clearing = 0; goto scan_wait; @@ -338,9 +336,9 @@ proc_subproc (DWORD what, DWORD val) case PROC_CLEARWAIT: /* Clear all "wait"ing threads. */ if (val) - sip_printf ("clear waiting threads"); + sigproc_printf ("clear waiting threads"); else - sip_printf ("looking for processes to reap"); + sigproc_printf ("looking for processes to reap"); clearing = val; scan_wait: @@ -350,12 +348,12 @@ proc_subproc (DWORD what, DWORD val) for (w = &waitq_head; w->next != NULL; w = w->next) { if ((potential_match = checkstate (w)) > 0) - sip_printf ("released waiting thread"); + sigproc_printf ("released waiting thread"); else if (!clearing && potential_match < 0) - sip_printf ("only found non-terminated children"); + sigproc_printf ("only found non-terminated children"); else if (potential_match <= 0) // nothing matched { - sip_printf ("waiting thread found no children"); + sigproc_printf ("waiting thread found no children"); HANDLE oldw = w->next->ev; if (clearing) w->next->status = -1; /* flag that a signal was received */ @@ -370,11 +368,11 @@ proc_subproc (DWORD what, DWORD val) } if (!clearing) - sip_printf ("finished processing terminated/stopped child"); + sigproc_printf ("finished processing terminated/stopped child"); else { waitq_head.next = NULL; - sip_printf ("finished clearing"); + sigproc_printf ("finished clearing"); } break; @@ -398,7 +396,7 @@ proc_subproc (DWORD what, DWORD val) break; wval->next = NULL; /* This will be last in the list */ - sip_printf ("wval->pid %d, wval->options %d", wval->pid, wval->options); + sigproc_printf ("wval->pid %d, wval->options %d", wval->pid, wval->options); /* If the first time for this thread, create a new event, otherwise * reset the event. @@ -426,7 +424,7 @@ proc_subproc (DWORD what, DWORD val) { w->next = NULL; // don't want to keep looking wval->ev = NULL; // flag that there are no children - sip_printf ("no appropriate children, %p, %p", + sigproc_printf ("no appropriate children, %p, %p", wval->thread_ev, wval->ev); } else if (wval->options & WNOHANG) @@ -435,23 +433,23 @@ proc_subproc (DWORD what, DWORD val) wval->pid = 0; // didn't find a pid if (!SetEvent (wval->ev)) // wake up wait4 () immediately system_printf ("Couldn't wake up wait event, %E"); - sip_printf ("WNOHANG and no terminated children, %p, %p", + sigproc_printf ("WNOHANG and no terminated children, %p, %p", wval->thread_ev, wval->ev); } } if (w->next != NULL) - sip_printf ("wait activated %p, %p", wval->thread_ev, wval->ev); + sigproc_printf ("wait activated %p, %p", wval->thread_ev, wval->ev); else if (wval->ev != NULL) - sip_printf ("wait activated %p. Reaped zombie.", wval->ev); + sigproc_printf ("wait activated %p. Reaped zombie.", wval->ev); else - sip_printf ("wait not activated %p, %p", wval->thread_ev, wval->ev); + sigproc_printf ("wait not activated %p, %p", wval->thread_ev, wval->ev); break; } out: sync_proc_subproc->release (); // Release the lock out1: - sip_printf ("returning %d", rc); + sigproc_printf ("returning %d", rc); return rc; } @@ -464,7 +462,7 @@ out1: void __stdcall proc_terminate (void) { - sip_printf ("nchildren %d, nzombies %d", nchildren, nzombies); + sigproc_printf ("nchildren %d, nzombies %d", nchildren, nzombies); /* Signal processing is assumed to be blocked in this routine. */ if (hwait_subproc) { @@ -506,7 +504,7 @@ proc_terminate (void) if (pchildren[i]->process_state == PID_NOT_IN_USE) continue; // Should never happen if (!pchildren[i]->hProcess) - sip_printf ("%d(%d) hProcess cleared already?", pchildren[i]->pid, + sigproc_printf ("%d(%d) hProcess cleared already?", pchildren[i]->pid, pchildren[i]->dwProcessId); else { @@ -514,13 +512,13 @@ proc_terminate (void) pchildren[i]->hProcess = NULL; if (!proc_exists (pchildren[i])) { - sip_printf ("%d(%d) doesn't exist", pchildren[i]->pid, + sigproc_printf ("%d(%d) doesn't exist", pchildren[i]->pid, pchildren[i]->dwProcessId); pchildren[i]->process_state = PID_NOT_IN_USE; /* a reaped child CGF FIXME -- still needed? */ } else { - sip_printf ("%d(%d) closing active child handle", pchildren[i]->pid, + sigproc_printf ("%d(%d) closing active child handle", pchildren[i]->pid, pchildren[i]->dwProcessId); pchildren[i]->ppid = 1; if (pchildren[i]->pgid == myself->pid) @@ -541,7 +539,7 @@ proc_terminate (void) delete m; } } - sip_printf ("leaving"); + sigproc_printf ("leaving"); } /* Clear pending signal from the sigtodo array @@ -563,11 +561,11 @@ sig_dispatch_pending (int justwake) int was_pending = pending_signals; #ifdef DEBUGGING - sip_printf ("pending_signals %d", was_pending); + sigproc_printf ("pending_signals %d", was_pending); #endif if (!was_pending && !justwake) #ifdef DEBUGGING - sip_printf ("no need to wake anything up"); + sigproc_printf ("no need to wake anything up"); #else ; #endif @@ -578,12 +576,12 @@ sig_dispatch_pending (int justwake) (void) sig_send (myself, __SIGFLUSH); else if (ReleaseSemaphore (sigcatch_nosync, 1, NULL)) #ifdef DEBUGGING - sip_printf ("woke up wait_sig"); + sigproc_printf ("woke up wait_sig"); #else ; #endif else if (no_signals_available ()) - /*sip_printf ("I'm going away now")*/; + /*sigproc_printf ("I'm going away now")*/; else system_printf ("%E releasing sigcatch_nosync(%p)", sigcatch_nosync); @@ -633,7 +631,7 @@ sigproc_init () } memset (w, 0, sizeof *w); // Just to be safe - sip_printf ("process/signal handling enabled(%x)", myself->process_state); + sigproc_printf ("process/signal handling enabled(%x)", myself->process_state); return; } @@ -658,7 +656,7 @@ sigproc_terminate (void) proc_terminate (); // Terminate process handling thread if (!sig_loop_wait) - sip_printf ("sigproc_terminate: sigproc handling not active"); + sigproc_printf ("sigproc_terminate: sigproc handling not active"); else { sigproc_printf ("entering"); @@ -680,7 +678,7 @@ sigproc_terminate (void) if (!myself->dwProcessId || myself->dwProcessId == GetCurrentProcessId ()) myself->process_state &= ~PID_ACTIVE; else - sip_printf ("Did not clear PID_ACTIVE since %d != %d", + sigproc_printf ("Did not clear PID_ACTIVE since %d != %d", myself->dwProcessId, GetCurrentProcessId ()); /* In case of a sigsuspend */ @@ -695,7 +693,7 @@ sigproc_terminate (void) ForceCloseHandle (sigcatch_nosync); } } - sip_printf ("done"); + sigproc_printf ("done"); } /* Set this so that subsequent tests will succeed. */ @@ -739,13 +737,13 @@ sig_send (_pinfo *p, int sig, DWORD ebp) */ if (!proc_can_be_signalled (p)) /* Is the process accepting messages? */ { - sip_printf ("invalid pid %d(%x), signal %d", + sigproc_printf ("invalid pid %d(%x), signal %d", p->pid, p->process_state, sig); set_errno (ESRCH); goto out; } - sip_printf ("pid %d, signal %d, its_me %d", p->pid, sig, its_me); + sigproc_printf ("pid %d, signal %d, its_me %d", p->pid, sig, its_me); if (its_me) { @@ -799,7 +797,7 @@ sigproc_printf ("ReleaseSemaphore failed, %E"); else { if (no_signals_available ()) - sip_printf ("I'm going away now"); + sigproc_printf ("I'm going away now"); else if ((int) GetLastError () == -1) rc = WaitForSingleObject (thiscomplete, 500); else @@ -820,13 +818,13 @@ sigproc_printf ("ReleaseSemaphore succeeded"); if (!wait_for_completion) { rc = WAIT_OBJECT_0; - sip_printf ("Not waiting for sigcomplete. its_me %d sig %d", its_me, sig); + sigproc_printf ("Not waiting for sigcomplete. its_me %d sig %d", its_me, sig); if (!its_me) ForceCloseHandle (thiscatch); } else { - sip_printf ("Waiting for thiscomplete %p", thiscomplete); + sigproc_printf ("Waiting for thiscomplete %p", thiscomplete); SetLastError (0); rc = WaitForSingleObject (thiscomplete, WSSC); @@ -856,7 +854,7 @@ sigproc_printf ("ReleaseSemaphore succeeded"); } out: - sip_printf ("returning %d from sending signal %d", rc, sig); + sigproc_printf ("returning %d from sending signal %d", rc, sig); return rc; } @@ -886,7 +884,7 @@ subproc_init (void) system_printf ("cannot create wait_subproc thread, %E"); ProtectHandle (events[0]); ProtectHandle (hwait_subproc); - sip_printf ("started wait_subproc thread %p", hwait_subproc); + sigproc_printf ("started wait_subproc thread %p", hwait_subproc); } /* Initialize some of the memory block passed to child processes @@ -919,7 +917,7 @@ checkstate (waitq *w) int i, x, potential_match = 0; _pinfo *child; - sip_printf ("nchildren %d, nzombies %d", nchildren, nzombies); + sigproc_printf ("nchildren %d, nzombies %d", nchildren, nzombies); /* Check already dead processes first to see if they match the criteria * given in w->next. @@ -934,7 +932,7 @@ checkstate (waitq *w) goto out; } - sip_printf ("checking alive children"); + sigproc_printf ("checking alive children"); /* No dead terminated children matched. Check for stopped children. */ for (i = 0; i < nchildren; i++) @@ -947,7 +945,7 @@ checkstate (waitq *w) } out: - sip_printf ("returning %d", potential_match); + sigproc_printf ("returning %d", potential_match); return potential_match; } @@ -966,7 +964,7 @@ getsem (_pinfo *p, const char *str, int init, int max) return NULL; } int wait = 10000; - sip_printf ("pid %d, ppid %d, wait %d, initializing %x", p->pid, p->ppid, wait, + sigproc_printf ("pid %d, ppid %d, wait %d, initializing %x", p->pid, p->ppid, wait, ISSTATE (p, PID_INITIALIZING)); for (int i = 0; ISSTATE (p, PID_INITIALIZING) && i < wait; i++) Sleep (1); @@ -1010,7 +1008,7 @@ getsem (_pinfo *p, const char *str, int init, int max) * Attempt to handle case where process is exiting as we try to grab * the mutex. */ -static __inline__ BOOL +static BOOL get_proc_lock (DWORD what, DWORD val) { Static int lastwhat = -1; @@ -1034,7 +1032,7 @@ get_proc_lock (DWORD what, DWORD val) static void __stdcall remove_child (int ci) { - sip_printf ("removing [%d], pid %d, handle %p, nchildren %d", + sigproc_printf ("removing [%d], pid %d, handle %p, nchildren %d", ci, pchildren[ci]->pid, hchildren[ci], nchildren); if (ci < --nchildren) { @@ -1050,7 +1048,7 @@ remove_child (int ci) static void __stdcall remove_zombie (int ci) { - sip_printf ("removing %d, pid %d, nzombies %d", ci, zombies[ci]->pid, + sigproc_printf ("removing %d, pid %d, nzombies %d", ci, zombies[ci]->pid, nzombies); if (zombies[ci]) @@ -1078,7 +1076,7 @@ stopped_or_terminated (waitq *parent_w, _pinfo *child) int potential_match; waitq *w = parent_w->next; - sip_printf ("considering pid %d", child->pid); + sigproc_printf ("considering pid %d", child->pid); if (w->pid == -1) potential_match = 1; else if (w->pid == 0) @@ -1101,7 +1099,7 @@ stopped_or_terminated (waitq *parent_w, _pinfo *child) if (!terminated) { - sip_printf ("stopped child"); + sigproc_printf ("stopped child"); w->status = (child->stopsig << 8) | 0x7f; child->stopsig = 0; } @@ -1229,7 +1227,7 @@ wait_sig (VOID *) rc -= WAIT_OBJECT_0; int dispatched = FALSE; - sip_printf ("awake"); + sigproc_printf ("awake"); /* A sigcatch semaphore has been signaled. Scan the sigtodo * array looking for any unprocessed signals. */ @@ -1246,12 +1244,12 @@ wait_sig (VOID *) (sigismember (& myself->getsigmask (), sig) || myself->process_state & PID_STOPPED)) { - sip_printf ("sig %d blocked", sig); + sigproc_printf ("sig %d blocked", sig); break; } /* Found a signal to process */ - sip_printf ("processing signal %d", sig); + sigproc_printf ("processing signal %d", sig); switch (sig) { case __SIGFLUSH: @@ -1265,7 +1263,7 @@ wait_sig (VOID *) /* Signalled from a child process that it has stopped */ case __SIGCHILDSTOPPED: - sip_printf ("Received child stopped notification"); + sigproc_printf ("Received child stopped notification"); dispatched |= sig_handle (SIGCHLD); if (proc_subproc (PROC_CHILDSTOPPED, 0)) dispatched |= 1; @@ -1273,7 +1271,7 @@ wait_sig (VOID *) /* A normal UNIX signal */ default: - sip_printf ("Got signal %d", sig); + sigproc_printf ("Got signal %d", sig); int wasdispatched = sig_handle (sig); dispatched |= wasdispatched; if (sig == SIGCHLD && wasdispatched) @@ -1308,10 +1306,10 @@ wait_sig (VOID *) if (dispatched < 0) pending_signals = 1; - sip_printf ("looping"); + sigproc_printf ("looping"); } - sip_printf ("done"); + sigproc_printf ("done"); return 0; } @@ -1319,7 +1317,7 @@ wait_sig (VOID *) static DWORD WINAPI wait_subproc (VOID *) { - sip_printf ("starting"); + sigproc_printf ("starting"); int errloop = 0; for (;;) @@ -1360,12 +1358,12 @@ wait_subproc (VOID *) rc -= WAIT_OBJECT_0; if (rc-- != 0) (void)proc_subproc (PROC_CHILDTERMINATED, rc); - sip_printf ("looping"); + sigproc_printf ("looping"); } ForceCloseHandle (events[0]); events[0] = NULL; - sip_printf ("done"); + sigproc_printf ("done"); return 0; } diff --git a/winsup/cygwin/strace.cc b/winsup/cygwin/strace.cc index c6656f9f0..a23ab5023 100644 --- a/winsup/cygwin/strace.cc +++ b/winsup/cygwin/strace.cc @@ -17,7 +17,6 @@ details. */ #define PROTECT(x) x[sizeof(x)-1] = 0 #define CHECK(x) if (x[sizeof(x)-1] != 0) { small_printf("array bound exceeded %d\n", __LINE__); ExitProcess(1); } - class strace NO_COPY strace; /* 'twould be nice to declare this in winsup.h but winsup.h doesn't require @@ -141,24 +140,30 @@ strace::write (unsigned category, const char *buf, int count) Warning: DO NOT SET ERRNO HERE! */ void -strace::prntf (unsigned category, const char *fmt,...) +strace::prntf (unsigned category, const char *fmt, ...) { DWORD err = GetLastError (); - if (active) + int count; + char buf[10000]; + va_list ap; + + PROTECT(buf); + SetLastError (err); + + va_start (ap, fmt); + count = this->vsprntf (buf, fmt, ap); + CHECK(buf); + if (category & _STRACE_SYSTEM) { - int count; - va_list ap; - char buf[10000]; - - PROTECT(buf); - va_start (ap, fmt); - SetLastError (err); - count = this->vsprntf (buf, fmt, ap); - va_end (ap); - CHECK(buf); - - this->write (category, buf, count); + DWORD done; + WriteFile (GetStdHandle (STD_ERROR_HANDLE), buf, count, &done, 0); + FlushFileBuffers (GetStdHandle (STD_ERROR_HANDLE)); } + +#ifndef NOSTRACE + if (active) + this->write (category, buf, count); +#endif SetLastError (err); } @@ -343,35 +348,4 @@ strace::wm (int message, int word, int lon) this->prntf (_STRACE_WM, "wndproc %d unknown %d %d", message, word, lon); } } - -/* Print a message on stderr (bypassing anything that could prevent the - message from being printed, for example a buggy or corrupted stdio). - This is used, for example, to print diagnostics of fatal errors. */ - -void -__system_printf (const char *fmt,...) -{ - char buf[6000]; - va_list ap; - int count; - - PROTECT (buf); - va_start (ap, fmt); - count = strace.vsprntf (buf, fmt, ap); - va_end (ap); - CHECK (buf); - - DWORD done; - WriteFile (GetStdHandle (STD_ERROR_HANDLE), buf, count, &done, 0); - FlushFileBuffers (GetStdHandle (STD_ERROR_HANDLE)); - -#ifndef NOSTRACE - if (strace.active) - strace.write (1, buf, count); -#endif - -#ifdef DEBUGGING -// try_to_debug (); -#endif -} #endif /*NOSTRACE*/ diff --git a/winsup/cygwin/winsup.h b/winsup/cygwin/winsup.h index 330c38ce2..4b61c4bbf 100644 --- a/winsup/cygwin/winsup.h +++ b/winsup/cygwin/winsup.h @@ -23,6 +23,10 @@ details. */ # define memset __builtin_memset #endif +#if !defined(__STDC_VERSION__) || __STDC_VERSION__ >= 199900L +#define NEW_MACRO_VARARGS +#endif + #include #include #include @@ -279,8 +283,11 @@ extern unsigned int signal_shift_subtract; #define MARK() mark (__FILE__,__LINE__) #endif -#define api_fatal(fmt, args...) \ - __api_fatal ("%P: *** " fmt,##args) +#ifdef NEW_MACRO_VARARGS +# define api_fatal(...) __api_fatal ("%P: *** " __VA_ARGS__) +#else +# define api_fatal(fmt, args...) __api_fatal ("%P: *** " fmt,## args) +#endif #undef issep #define issep(ch) (strchr (" \t\n\r", (ch)) != NULL) @@ -325,8 +332,6 @@ void events_terminate (void); void __stdcall close_all_files (void); -extern class strace strace; - /* Invisible window initialization/termination. */ HWND __stdcall gethwnd (void); void __stdcall window_terminate (void);