[newlib-cygwin.git] / winsup / cygwin / strace.cc

/* strace.cc: system/windows tracing

   Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   2006, 2007, 2008 Red Hat, Inc.

This file is part of Cygwin.

This software is a copyrighted work licensed under the terms of the
Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
details. */

#include "winsup.h"
#include <wingdi.h>
#include <winuser.h>
#include <ctype.h>
#include "cygerrno.h"
#include "pinfo.h"
#include "perprocess.h"
#include "cygwin_version.h"
#include "cygthread.h"
#include "path.h"
#include "fhandler.h"
#include "dtable.h"
#include "cygheap.h"
#include "child_info.h"

#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;

#ifndef NOSTRACE

void
strace::hello ()
{
  if (_active || !being_debugged ())
    return;

  char buf[30];
  __small_sprintf (buf, "cYg%8x %x", _STRACE_INTERFACE_ACTIVATE_ADDR, &_active);
  OutputDebugString (buf);

  if (active ())
    {
      char pidbuf[40];
      if (myself->progname[0])
	__small_sprintf (pidbuf, "(pid %d, ppid %d)", myself->pid, myself->ppid ?: 1);
      else
	{
	  GetModuleFileName (NULL, myself->progname, sizeof (myself->progname));
	  __small_sprintf (pidbuf, "(windows pid %d)", GetCurrentProcessId ());
	}
      prntf (1, NULL, "**********************************************");
      prntf (1, NULL, "Program name: %s %s", myself->progname, pidbuf);
      prntf (1, NULL, "App version:  %d.%d, api: %d.%d",
	     user_data->dll_major, user_data->dll_minor,
	     user_data->api_major, user_data->api_minor);
      prntf (1, NULL, "DLL version:  %d.%d, api: %d.%d",
	     cygwin_version.dll_major, cygwin_version.dll_minor,
	     cygwin_version.api_major, cygwin_version.api_minor);
      prntf (1, NULL, "DLL build:    %s", cygwin_version.dll_build_date);
      prntf (1, NULL, "OS version:   Windows %s", wincap.osname ());
      if (cygheap)
	prntf (1, NULL, "Heap size:    %u", cygheap->user_heap.chunk);
      prntf (1, NULL, "**********************************************");
    }
}

int
strace::microseconds ()
{
  static hires_us now;
  return (int) now.usecs (true);
}

static int __stdcall
getfunc (char *in_dst, const char *func)
{
  const char *p;
  const char *pe;
  char *dst = in_dst;
  for (p = func; (pe = strchr (p, '(')); p = pe + 1)
    if (isalnum ((int)pe[-1]) || pe[-1] == '_')
      break;
    else if (isspace ((int)pe[-1]))
      {
	pe--;
	break;
      }
  if (!pe)
    pe = strchr (func, '\0');
  for (p = pe; p > func; p--)
    if (p != pe && *p == ' ')
      {
	p++;
	break;
      }
  if (*p == '*')
    p++;
  while (p < pe)
    *dst++ = *p++;

  *dst++ = ':';
  *dst++ = ' ';
  *dst = '\0';

  return dst - in_dst;
}

static char *
mypid (char *buf)
{
  if (myself && myself->pid)
    __small_sprintf (buf, "%d", myself->pid);
  else
    __small_sprintf (buf, "(%d)", cygwin_pid (GetCurrentProcessId ()));
  return buf;
}

extern "C" char *__progname;

/* sprintf analog for use by output routines. */
int
strace::vsprntf (char *buf, const char *func, const char *infmt, va_list ap)
{
  int count;
  char fmt[80];
  static NO_COPY bool nonewline = false;
  DWORD err = GetLastError ();
  const char *tn = cygthread::name ();

  int microsec = microseconds ();
  lmicrosec = microsec;

  __small_sprintf (fmt, "%7d [%s] %s ", microsec, tn, "%s %s%s");

  SetLastError (err);

  if (nonewline)
    count = 0;
  else
    {
      char *pn;
      if (!cygwin_finished_initializing)
	pn = myself ? myself->progname : NULL;
      else if (__progname)
	pn = __progname;
      else
	pn = NULL;

      char *p;
      char progname[NT_MAX_PATH];
      if (!pn)
	GetModuleFileName (NULL, pn = progname, sizeof (progname));
      if (!pn)
	/* hmm */;
      else if ((p = strrchr (pn, '\\')) != NULL)
	p++;
      else if ((p = strrchr (pn, '/')) != NULL)
	p++;
      else
	p = pn;
      if (p != progname)
	strcpy (progname, p);
      if ((p = strrchr (progname, '.')) != NULL
	  && ascii_strcasematch (p, ".exe"))
	*p = '\000';
      p = progname;
      char tmpbuf[20];
      count = __small_sprintf (buf, fmt, p && *p ? p : "?", mypid (tmpbuf),
			       execing ? "!" : "");
      if (func)
	count += getfunc (buf + count, func);
    }

  count += __small_vsprintf (buf + count, infmt, ap);
  char *p;
  for (p = buf + count; p > buf; p--)
    switch (p[-1])
      {
	case '\n':
	  p[-1] = '\0';
	  break;
	case '\b':
	  *--p = '\0';
	   nonewline = true;
	  goto done;
	default:
	  goto addnl;
      }

addnl:
  *p++ = '\n';
  *p = '\0';
  nonewline = false;

done:
  return p - buf;
}

/* Write to strace file or strace queue. */
void
strace::write (unsigned category, const char *buf, int count)
{
# define PREFIX (3 + 8 + 1 + 8 + 1)
  char outbuf[PREFIX + 1 + count + 1];
# define outstuff (outbuf + 12)
  __small_sprintf (outstuff, "%x %s", category, buf);
  __small_sprintf (outbuf, "cYg%08x", strlen (outstuff) + 1);
  outstuff[-1] = ' ';
  OutputDebugString (outbuf);
#undef outstuff
#undef PREFIX
}

void
strace::write_childpid (child_info& ch, DWORD pid)
{
  char buf[30];

  if (!attached () || !being_debugged ())
    return;
  WaitForSingleObject (ch.subproc_ready, 30000);
  __small_sprintf (buf, "cYg%8x %x", _STRACE_CHILD_PID, pid);
  OutputDebugString (buf);
}

/* Printf function used when tracing system calls.
   Warning: DO NOT SET ERRNO HERE! */

void
strace::vprntf (unsigned category, const char *func, const char *fmt, va_list ap)
{
  DWORD err = GetLastError ();
  int len;
  char buf[10000];

  PROTECT (buf);
  SetLastError (err);

  len = vsprntf (buf, func, fmt, ap);
  CHECK (buf);
  if (category & _STRACE_SYSTEM)
    {
      DWORD done;
      WriteFile (GetStdHandle (STD_ERROR_HANDLE), buf, len, &done, 0);
      FlushFileBuffers (GetStdHandle (STD_ERROR_HANDLE));
      /* Make sure that the message shows up on the screen, too, since this is
	 a serious error. */
      if (GetFileType (GetStdHandle (STD_ERROR_HANDLE)) != FILE_TYPE_CHAR)
	{
	  HANDLE h = CreateFile ("CONOUT$", GENERIC_READ | GENERIC_WRITE,
				 FILE_SHARE_WRITE | FILE_SHARE_WRITE,
				 &sec_none, OPEN_EXISTING, 0, 0);
	  if (h != INVALID_HANDLE_VALUE)
	    WriteFile (h, buf, len, &done, 0);
	  CloseHandle (h);
	}
    }

#ifndef NOSTRACE
  if (active ())
    write (category, buf, len);
#endif
  SetLastError (err);
}

void
strace::prntf (unsigned category, const char *func, const char *fmt, ...)
{
  va_list ap;

  va_start (ap, fmt);
  vprntf (category, func, fmt, ap);
}

extern "C" void
strace_printf (unsigned category, const char *func, const char *fmt, ...)
{
  va_list ap;

  if ((category & _STRACE_SYSTEM) || strace.active ())
    {
      va_start (ap, fmt);
      strace.vprntf (category, func, fmt, ap);
    }
}

static NO_COPY struct tab
{
  int v;
  const char *n;
}
ta[] =
{
  {  WM_NULL, "WM_NULL"  },
  {  WM_CREATE, "WM_CREATE"  },
  {  WM_DESTROY, "WM_DESTROY"  },
  {  WM_MOVE, "WM_MOVE"  },
  {  WM_SIZE, "WM_SIZE"  },
  {  WM_ACTIVATE, "WM_ACTIVATE"  },
  {  WM_SETFOCUS, "WM_SETFOCUS"  },
  {  WM_KILLFOCUS, "WM_KILLFOCUS"  },
  {  WM_ENABLE, "WM_ENABLE"  },
  {  WM_SETREDRAW, "WM_SETREDRAW"  },
  {  WM_SETTEXT, "WM_SETTEXT"  },
  {  WM_GETTEXT, "WM_GETTEXT"  },
  {  WM_GETTEXTLENGTH, "WM_GETTEXTLENGTH"  },
  {  WM_PAINT, "WM_PAINT"  },
  {  WM_CLOSE, "WM_CLOSE"  },
  {  WM_QUERYENDSESSION, "WM_QUERYENDSESSION"  },
  {  WM_QUIT, "WM_QUIT"  },
  {  WM_QUERYOPEN, "WM_QUERYOPEN"  },
  {  WM_ERASEBKGND, "WM_ERASEBKGND"  },
  {  WM_SYSCOLORCHANGE, "WM_SYSCOLORCHANGE"  },
  {  WM_ENDSESSION, "WM_ENDSESSION"  },
  {  WM_SHOWWINDOW, "WM_SHOWWINDOW"  },
  {  WM_WININICHANGE, "WM_WININICHANGE"  },
  {  WM_DEVMODECHANGE, "WM_DEVMODECHANGE"  },
  {  WM_ACTIVATEAPP, "WM_ACTIVATEAPP"  },
  {  WM_FONTCHANGE, "WM_FONTCHANGE"  },
  {  WM_TIMECHANGE, "WM_TIMECHANGE"  },
  {  WM_CANCELMODE, "WM_CANCELMODE"  },
  {  WM_SETCURSOR, "WM_SETCURSOR"  },
  {  WM_MOUSEACTIVATE, "WM_MOUSEACTIVATE"  },
  {  WM_CHILDACTIVATE, "WM_CHILDACTIVATE"  },
  {  WM_QUEUESYNC, "WM_QUEUESYNC"  },
  {  WM_GETMINMAXINFO, "WM_GETMINMAXINFO"  },
  {  WM_PAINTICON, "WM_PAINTICON"  },
  {  WM_ICONERASEBKGND, "WM_ICONERASEBKGND"  },
  {  WM_NEXTDLGCTL, "WM_NEXTDLGCTL"  },
  {  WM_SPOOLERSTATUS, "WM_SPOOLERSTATUS"  },
  {  WM_DRAWITEM, "WM_DRAWITEM"  },
  {  WM_MEASUREITEM, "WM_MEASUREITEM"  },
  {  WM_DELETEITEM, "WM_DELETEITEM"  },
  {  WM_VKEYTOITEM, "WM_VKEYTOITEM"  },
  {  WM_CHARTOITEM, "WM_CHARTOITEM"  },
  {  WM_SETFONT, "WM_SETFONT"  },
  {  WM_GETFONT, "WM_GETFONT"  },
  {  WM_SETHOTKEY, "WM_SETHOTKEY"  },
  {  WM_GETHOTKEY, "WM_GETHOTKEY"  },
  {  WM_QUERYDRAGICON, "WM_QUERYDRAGICON"  },
  {  WM_COMPAREITEM, "WM_COMPAREITEM"  },
  {  WM_COMPACTING, "WM_COMPACTING"  },
  {  WM_WINDOWPOSCHANGING, "WM_WINDOWPOSCHANGING"  },
  {  WM_WINDOWPOSCHANGED, "WM_WINDOWPOSCHANGED"  },
  {  WM_POWER, "WM_POWER"  },
  {  WM_COPYDATA, "WM_COPYDATA"  },
  {  WM_CANCELJOURNAL, "WM_CANCELJOURNAL"  },
  {  WM_NCCREATE, "WM_NCCREATE"  },
  {  WM_NCDESTROY, "WM_NCDESTROY"  },
  {  WM_NCCALCSIZE, "WM_NCCALCSIZE"  },
  {  WM_NCHITTEST, "WM_NCHITTEST"  },
  {  WM_NCPAINT, "WM_NCPAINT"  },
  {  WM_NCACTIVATE, "WM_NCACTIVATE"  },
  {  WM_GETDLGCODE, "WM_GETDLGCODE"  },
  {  WM_NCMOUSEMOVE, "WM_NCMOUSEMOVE"  },
  {  WM_NCLBUTTONDOWN, "WM_NCLBUTTONDOWN"  },
  {  WM_NCLBUTTONUP, "WM_NCLBUTTONUP"  },
  {  WM_NCLBUTTONDBLCLK, "WM_NCLBUTTONDBLCLK"  },
  {  WM_NCRBUTTONDOWN, "WM_NCRBUTTONDOWN"  },
  {  WM_NCRBUTTONUP, "WM_NCRBUTTONUP"  },
  {  WM_NCRBUTTONDBLCLK, "WM_NCRBUTTONDBLCLK"  },
  {  WM_NCMBUTTONDOWN, "WM_NCMBUTTONDOWN"  },
  {  WM_NCMBUTTONUP, "WM_NCMBUTTONUP"  },
  {  WM_NCMBUTTONDBLCLK, "WM_NCMBUTTONDBLCLK"  },
  {  WM_KEYFIRST, "WM_KEYFIRST"  },
  {  WM_KEYDOWN, "WM_KEYDOWN"  },
  {  WM_KEYUP, "WM_KEYUP"  },
  {  WM_CHAR, "WM_CHAR"  },
  {  WM_DEADCHAR, "WM_DEADCHAR"  },
  {  WM_SYSKEYDOWN, "WM_SYSKEYDOWN"  },
  {  WM_SYSKEYUP, "WM_SYSKEYUP"  },
  {  WM_SYSCHAR, "WM_SYSCHAR"  },
  {  WM_SYSDEADCHAR, "WM_SYSDEADCHAR"  },
  {  WM_KEYLAST, "WM_KEYLAST"  },
  {  WM_INITDIALOG, "WM_INITDIALOG"  },
  {  WM_COMMAND, "WM_COMMAND"  },
  {  WM_SYSCOMMAND, "WM_SYSCOMMAND"  },
  {  WM_TIMER, "WM_TIMER"  },
  {  WM_HSCROLL, "WM_HSCROLL"  },
  {  WM_VSCROLL, "WM_VSCROLL"  },
  {  WM_INITMENU, "WM_INITMENU"  },
  {  WM_INITMENUPOPUP, "WM_INITMENUPOPUP"  },
  {  WM_MENUSELECT, "WM_MENUSELECT"  },
  {  WM_MENUCHAR, "WM_MENUCHAR"  },
  {  WM_ENTERIDLE, "WM_ENTERIDLE"  },
  {  WM_CTLCOLORMSGBOX, "WM_CTLCOLORMSGBOX"  },
  {  WM_CTLCOLOREDIT, "WM_CTLCOLOREDIT"  },
  {  WM_CTLCOLORLISTBOX, "WM_CTLCOLORLISTBOX"  },
  {  WM_CTLCOLORBTN, "WM_CTLCOLORBTN"  },
  {  WM_CTLCOLORDLG, "WM_CTLCOLORDLG"  },
  {  WM_CTLCOLORSCROLLBAR, "WM_CTLCOLORSCROLLBAR"  },
  {  WM_CTLCOLORSTATIC, "WM_CTLCOLORSTATIC"  },
  {  WM_MOUSEFIRST, "WM_MOUSEFIRST"  },
  {  WM_MOUSEMOVE, "WM_MOUSEMOVE"  },
  {  WM_LBUTTONDOWN, "WM_LBUTTONDOWN"  },
  {  WM_LBUTTONUP, "WM_LBUTTONUP"  },
  {  WM_LBUTTONDBLCLK, "WM_LBUTTONDBLCLK"  },
  {  WM_RBUTTONDOWN, "WM_RBUTTONDOWN"  },
  {  WM_RBUTTONUP, "WM_RBUTTONUP"  },
  {  WM_RBUTTONDBLCLK, "WM_RBUTTONDBLCLK"  },
  {  WM_MBUTTONDOWN, "WM_MBUTTONDOWN"  },
  {  WM_MBUTTONUP, "WM_MBUTTONUP"  },
  {  WM_MBUTTONDBLCLK, "WM_MBUTTONDBLCLK"  },
  {  WM_MOUSELAST, "WM_MOUSELAST"  },
  {  WM_PARENTNOTIFY, "WM_PARENTNOTIFY"  },
  {  WM_ENTERMENULOOP, "WM_ENTERMENULOOP"  },
  {  WM_EXITMENULOOP, "WM_EXITMENULOOP"  },
  {  WM_MDICREATE, "WM_MDICREATE"  },
  {  WM_MDIDESTROY, "WM_MDIDESTROY"  },
  {  WM_MDIACTIVATE, "WM_MDIACTIVATE"  },
  {  WM_MDIRESTORE, "WM_MDIRESTORE"  },
  {  WM_MDINEXT, "WM_MDINEXT"  },
  {  WM_MDIMAXIMIZE, "WM_MDIMAXIMIZE"  },
  {  WM_MDITILE, "WM_MDITILE"  },
  {  WM_MDICASCADE, "WM_MDICASCADE"  },
  {  WM_MDIICONARRANGE, "WM_MDIICONARRANGE"  },
  {  WM_MDIGETACTIVE, "WM_MDIGETACTIVE"  },
  {  WM_MDISETMENU, "WM_MDISETMENU"  },
  {  WM_DROPFILES, "WM_DROPFILES"  },
  {  WM_MDIREFRESHMENU, "WM_MDIREFRESHMENU"  },
  {  WM_CUT, "WM_CUT"  },
  {  WM_COPY, "WM_COPY"  },
  {  WM_PASTE, "WM_PASTE"  },
  {  WM_CLEAR, "WM_CLEAR"  },
  {  WM_UNDO, "WM_UNDO"  },
  {  WM_RENDERFORMAT, "WM_RENDERFORMAT"  },
  {  WM_RENDERALLFORMATS, "WM_RENDERALLFORMATS"  },
  {  WM_DESTROYCLIPBOARD, "WM_DESTROYCLIPBOARD"  },
  {  WM_DRAWCLIPBOARD, "WM_DRAWCLIPBOARD"  },
  {  WM_PAINTCLIPBOARD, "WM_PAINTCLIPBOARD"  },
  {  WM_VSCROLLCLIPBOARD, "WM_VSCROLLCLIPBOARD"  },
  {  WM_SIZECLIPBOARD, "WM_SIZECLIPBOARD"  },
  {  WM_ASKCBFORMATNAME, "WM_ASKCBFORMATNAME"  },
  {  WM_CHANGECBCHAIN, "WM_CHANGECBCHAIN"  },
  {  WM_HSCROLLCLIPBOARD, "WM_HSCROLLCLIPBOARD"  },
  {  WM_QUERYNEWPALETTE, "WM_QUERYNEWPALETTE"  },
  {  WM_PALETTEISCHANGING, "WM_PALETTEISCHANGING"  },
  {  WM_PALETTECHANGED, "WM_PALETTECHANGED"  },
  {  WM_HOTKEY, "WM_HOTKEY"  },
  {  WM_PENWINFIRST, "WM_PENWINFIRST"  },
  {  WM_PENWINLAST, "WM_PENWINLAST"  },
  {  WM_ASYNCIO, "ASYNCIO"  },
  {  0, 0  }};

void
strace::wm (int message, int word, int lon)
{
  if (active ())
    {
      int i;

      for (i = 0; ta[i].n; i++)
	{
	  if (ta[i].v == message)
	    {
	      prntf (_STRACE_WM, NULL, "wndproc %d %s %d %d", message, ta[i].n, word, lon);
	      return;
	    }
	}
      prntf (_STRACE_WM, NULL, "wndproc %d unknown  %d %d", message, word, lon);
    }
}
#endif /*NOSTRACE*/
Commit	Line	Data
1fd5e000 CF	1	/* strace.cc: system/windows tracing
1fd5e000 CF	2
68f62c98	3	Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
a7d2cc16	4	2006, 2007, 2008 Red Hat, Inc.
1fd5e000 CF	5
	6	This file is part of Cygwin.
	7
	8	This software is a copyrighted work licensed under the terms of the
	9	Cygwin license. Please consult the file "CYGWIN_LICENSE" for
	10	details. */
	11
4c8d72de	12	#include "winsup.h"
d0b178fe DD	13	#include <wingdi.h>
d0b178fe DD	14	#include <winuser.h>
20d7f758	15	#include <ctype.h>
169c465a	16	#include "cygerrno.h"
e2ebe117	17	#include "pinfo.h"
494a66d9 CF	18	#include "perprocess.h"
494a66d9 CF	19	#include "cygwin_version.h"
b6bd7037	20	#include "cygthread.h"
1cc651ec	21	#include "path.h"
7ac61736	22	#include "fhandler.h"
1cc651ec	23	#include "dtable.h"
1cc651ec	24	#include "cygheap.h"
5d970405	25	#include "child_info.h"
1fd5e000	26
f0227ea3 CF	27	#define PROTECT(x) x[sizeof (x)-1] = 0
f0227ea3 CF	28	#define CHECK(x) if (x[sizeof (x)-1] != 0) { small_printf ("array bound exceeded %d\n", __LINE__); ExitProcess (1); }
1fd5e000	29
03a2ce9a	30	class strace NO_COPY strace;
1fd5e000	31
1fd5e000 CF	32	#ifndef NOSTRACE
1fd5e000 CF	33
494a66d9	34	void
c90e1cf1	35	strace::hello ()
494a66d9	36	{
5d970405	37	if (_active \|\| !being_debugged ())
918a268c CF	38	return;
918a268c CF	39
5d970405 CF	40	char buf[30];
5d970405 CF	41	__small_sprintf (buf, "cYg%8x %x", _STRACE_INTERFACE_ACTIVATE_ADDR, &_active);
494a66d9 CF	42	OutputDebugString (buf);
494a66d9 CF	43
5d970405	44	if (active ())
494a66d9	45	{
5d970405 CF	46	char pidbuf[40];
	47	if (myself->progname[0])
	48	__small_sprintf (pidbuf, "(pid %d, ppid %d)", myself->pid, myself->ppid ?: 1);
	49	else
	50	{
	51	GetModuleFileName (NULL, myself->progname, sizeof (myself->progname));
	52	__small_sprintf (pidbuf, "(windows pid %d)", GetCurrentProcessId ());
	53	}
494a66d9	54	prntf (1, NULL, "**********************************************");
5d970405	55	prntf (1, NULL, "Program name: %s %s", myself->progname, pidbuf);
494a66d9 CF	56	prntf (1, NULL, "App version: %d.%d, api: %d.%d",
	57	user_data->dll_major, user_data->dll_minor,
	58	user_data->api_major, user_data->api_minor);
	59	prntf (1, NULL, "DLL version: %d.%d, api: %d.%d",
	60	cygwin_version.dll_major, cygwin_version.dll_minor,
	61	cygwin_version.api_major, cygwin_version.api_minor);
	62	prntf (1, NULL, "DLL build: %s", cygwin_version.dll_build_date);
	63	prntf (1, NULL, "OS version: Windows %s", wincap.osname ());
5d970405 CF	64	if (cygheap)
5d970405 CF	65	prntf (1, NULL, "Heap size: %u", cygheap->user_heap.chunk);
494a66d9 CF	66	prntf (1, NULL, "**********************************************");
	67	}
	68	}
	69
5abc9b83	70	int
60b68f0d	71	strace::microseconds ()
1fd5e000	72	{
9d0efbb3	73	static hires_us now;
60b68f0d	74	return (int) now.usecs (true);
1fd5e000	75	}
1fd5e000	76
20d7f758 CF	77	static int __stdcall
	78	getfunc (char in_dst, const char func)
	79	{
	80	const char *p;
	81	const char *pe;
	82	char *dst = in_dst;
	83	for (p = func; (pe = strchr (p, '(')); p = pe + 1)
	84	if (isalnum ((int)pe[-1]) \|\| pe[-1] == '_')
	85	break;
f0227ea3	86	else if (isspace ((int)pe[-1]))
20d7f758 CF	87	{
	88	pe--;
	89	break;
	90	}
	91	if (!pe)
	92	pe = strchr (func, '\0');
	93	for (p = pe; p > func; p--)
	94	if (p != pe && *p == ' ')
	95	{
	96	p++;
	97	break;
	98	}
	99	if (p == '')
	100	p++;
	101	while (p < pe)
	102	dst++ = p++;
	103
	104	*dst++ = ':';
	105	*dst++ = ' ';
	106	*dst = '\0';
	107
	108	return dst - in_dst;
	109	}
	110
5d970405 CF	111	static char *
	112	mypid (char *buf)
	113	{
	114	if (myself && myself->pid)
	115	__small_sprintf (buf, "%d", myself->pid);
	116	else
	117	__small_sprintf (buf, "(%d)", cygwin_pid (GetCurrentProcessId ()));
	118	return buf;
	119	}
	120
57bf29e8 CF	121	extern "C" char *__progname;
57bf29e8 CF	122
1fd5e000	123	/* sprintf analog for use by output routines. */
5abc9b83	124	int
20d7f758	125	strace::vsprntf (char buf, const char func, const char *infmt, va_list ap)
1fd5e000 CF	126	{
1fd5e000 CF	127	int count;
d542443e	128	char fmt[80];
2e008fb9	129	static NO_COPY bool nonewline = false;
1fd5e000	130	DWORD err = GetLastError ();
b6bd7037	131	const char *tn = cygthread::name ();
1fd5e000	132
5abc9b83	133	int microsec = microseconds ();
1fd5e000 CF	134	lmicrosec = microsec;
1fd5e000 CF	135
5d970405	136	__small_sprintf (fmt, "%7d [%s] %s ", microsec, tn, "%s %s%s");
1fd5e000 CF	137
1fd5e000 CF	138	SetLastError (err);
20d7f758	139
1fd5e000	140	if (nonewline)
20d7f758	141	count = 0;
1fd5e000 CF	142	else
1fd5e000 CF	143	{
5d970405 CF	144	char *pn;
	145	if (!cygwin_finished_initializing)
	146	pn = myself ? myself->progname : NULL;
	147	else if (__progname)
	148	pn = __progname;
	149	else
	150	pn = NULL;
	151
	152	char *p;
7b4b41ab	153	char progname[NT_MAX_PATH];
1ec4f618	154	if (!pn)
5d970405 CF	155	GetModuleFileName (NULL, pn = progname, sizeof (progname));
	156	if (!pn)
	157	/* hmm */;
1ec4f618	158	else if ((p = strrchr (pn, '\\')) != NULL)
57bf29e8 CF	159	p++;
57bf29e8 CF	160	else if ((p = strrchr (pn, '/')) != NULL)
d542443e	161	p++;
1fd5e000	162	else
57bf29e8	163	p = pn;
5d970405 CF	164	if (p != progname)
5d970405 CF	165	strcpy (progname, p);
c69d873f CV	166	if ((p = strrchr (progname, '.')) != NULL
c69d873f CV	167	&& ascii_strcasematch (p, ".exe"))
d542443e CF	168	*p = '\000';
d542443e CF	169	p = progname;
5d970405 CF	170	char tmpbuf[20];
5d970405 CF	171	count = __small_sprintf (buf, fmt, p && *p ? p : "?", mypid (tmpbuf),
4c45a897	172	execing ? "!" : "");
20d7f758 CF	173	if (func)
20d7f758 CF	174	count += getfunc (buf + count, func);
1fd5e000 CF	175	}
	176
	177	count += __small_vsprintf (buf + count, infmt, ap);
	178	char *p;
	179	for (p = buf + count; p > buf; p--)
	180	switch (p[-1])
	181	{
	182	case '\n':
	183	p[-1] = '\0';
	184	break;
	185	case '\b':
	186	*--p = '\0';
2e008fb9	187	nonewline = true;
1fd5e000 CF	188	goto done;
	189	default:
	190	goto addnl;
	191	}
	192
	193	addnl:
	194	*p++ = '\n';
	195	*p = '\0';
2e008fb9	196	nonewline = false;
1fd5e000 CF	197
	198	done:
	199	return p - buf;
	200	}
	201
	202	/* Write to strace file or strace queue. */
5abc9b83 CF	203	void
5abc9b83 CF	204	strace::write (unsigned category, const char *buf, int count)
1fd5e000 CF	205	{
	206	# define PREFIX (3 + 8 + 1 + 8 + 1)
	207	char outbuf[PREFIX + 1 + count + 1];
	208	# define outstuff (outbuf + 12)
	209	__small_sprintf (outstuff, "%x %s", category, buf);
	210	__small_sprintf (outbuf, "cYg%08x", strlen (outstuff) + 1);
	211	outstuff[-1] = ' ';
	212	OutputDebugString (outbuf);
4c45a897 CF	213	#undef outstuff
4c45a897 CF	214	#undef PREFIX
1fd5e000 CF	215	}
1fd5e000 CF	216
5d970405 CF	217	void
	218	strace::write_childpid (child_info& ch, DWORD pid)
	219	{
	220	char buf[30];
	221
	222	if (!attached () \|\| !being_debugged ())
	223	return;
5d970405	224	WaitForSingleObject (ch.subproc_ready, 30000);
5d970405 CF	225	__small_sprintf (buf, "cYg%8x %x", _STRACE_CHILD_PID, pid);
	226	OutputDebugString (buf);
	227	}
	228
1fd5e000 CF	229	/* Printf function used when tracing system calls.
	230	Warning: DO NOT SET ERRNO HERE! */
	231
	232	void
88429768	233	strace::vprntf (unsigned category, const char func, const char fmt, va_list ap)
1fd5e000 CF	234	{
1fd5e000 CF	235	DWORD err = GetLastError ();
a16b738d	236	int len;
a5a965ff	237	char buf[10000];
1fd5e000	238
c90e1cf1	239	PROTECT (buf);
a5a965ff	240	SetLastError (err);
1fd5e000	241
a16b738d	242	len = vsprntf (buf, func, fmt, ap);
c90e1cf1	243	CHECK (buf);
a5a965ff CF	244	if (category & _STRACE_SYSTEM)
	245	{
	246	DWORD done;
a16b738d	247	WriteFile (GetStdHandle (STD_ERROR_HANDLE), buf, len, &done, 0);
a5a965ff	248	FlushFileBuffers (GetStdHandle (STD_ERROR_HANDLE));
a16b738d CF	249	/* Make sure that the message shows up on the screen, too, since this is
	250	a serious error. */
	251	if (GetFileType (GetStdHandle (STD_ERROR_HANDLE)) != FILE_TYPE_CHAR)
	252	{
	253	HANDLE h = CreateFile ("CONOUT$", GENERIC_READ \| GENERIC_WRITE,
	254	FILE_SHARE_WRITE \| FILE_SHARE_WRITE,
	255	&sec_none, OPEN_EXISTING, 0, 0);
	256	if (h != INVALID_HANDLE_VALUE)
	257	WriteFile (h, buf, len, &done, 0);
	258	CloseHandle (h);
	259	}
1fd5e000	260	}
a5a965ff CF	261
a5a965ff CF	262	#ifndef NOSTRACE
5d970405	263	if (active ())
a16b738d	264	write (category, buf, len);
a5a965ff	265	#endif
1fd5e000 CF	266	SetLastError (err);
	267	}
	268
88429768 CV	269	void
	270	strace::prntf (unsigned category, const char func, const char fmt, ...)
	271	{
	272	va_list ap;
	273
	274	va_start (ap, fmt);
335556d5	275	vprntf (category, func, fmt, ap);
88429768 CV	276	}
	277
	278	extern "C" void
	279	strace_printf (unsigned category, const char func, const char fmt, ...)
	280	{
	281	va_list ap;
	282
5d970405	283	if ((category & _STRACE_SYSTEM) \|\| strace.active ())
88429768 CV	284	{
	285	va_start (ap, fmt);
	286	strace.vprntf (category, func, fmt, ap);
	287	}
	288	}
	289
bc6ed549	290	static NO_COPY struct tab
1fd5e000 CF	291	{
	292	int v;
	293	const char *n;
	294	}
	295	ta[] =
	296	{
	297	{ WM_NULL, "WM_NULL" },
	298	{ WM_CREATE, "WM_CREATE" },
	299	{ WM_DESTROY, "WM_DESTROY" },
	300	{ WM_MOVE, "WM_MOVE" },
	301	{ WM_SIZE, "WM_SIZE" },
	302	{ WM_ACTIVATE, "WM_ACTIVATE" },
	303	{ WM_SETFOCUS, "WM_SETFOCUS" },
	304	{ WM_KILLFOCUS, "WM_KILLFOCUS" },
	305	{ WM_ENABLE, "WM_ENABLE" },
	306	{ WM_SETREDRAW, "WM_SETREDRAW" },
	307	{ WM_SETTEXT, "WM_SETTEXT" },
	308	{ WM_GETTEXT, "WM_GETTEXT" },
	309	{ WM_GETTEXTLENGTH, "WM_GETTEXTLENGTH" },
	310	{ WM_PAINT, "WM_PAINT" },
	311	{ WM_CLOSE, "WM_CLOSE" },
	312	{ WM_QUERYENDSESSION, "WM_QUERYENDSESSION" },
	313	{ WM_QUIT, "WM_QUIT" },
	314	{ WM_QUERYOPEN, "WM_QUERYOPEN" },
	315	{ WM_ERASEBKGND, "WM_ERASEBKGND" },
	316	{ WM_SYSCOLORCHANGE, "WM_SYSCOLORCHANGE" },
	317	{ WM_ENDSESSION, "WM_ENDSESSION" },
	318	{ WM_SHOWWINDOW, "WM_SHOWWINDOW" },
	319	{ WM_WININICHANGE, "WM_WININICHANGE" },
	320	{ WM_DEVMODECHANGE, "WM_DEVMODECHANGE" },
	321	{ WM_ACTIVATEAPP, "WM_ACTIVATEAPP" },
	322	{ WM_FONTCHANGE, "WM_FONTCHANGE" },
	323	{ WM_TIMECHANGE, "WM_TIMECHANGE" },
	324	{ WM_CANCELMODE, "WM_CANCELMODE" },
	325	{ WM_SETCURSOR, "WM_SETCURSOR" },
	326	{ WM_MOUSEACTIVATE, "WM_MOUSEACTIVATE" },
	327	{ WM_CHILDACTIVATE, "WM_CHILDACTIVATE" },
	328	{ WM_QUEUESYNC, "WM_QUEUESYNC" },
	329	{ WM_GETMINMAXINFO, "WM_GETMINMAXINFO" },
	330	{ WM_PAINTICON, "WM_PAINTICON" },
	331	{ WM_ICONERASEBKGND, "WM_ICONERASEBKGND" },
	332	{ WM_NEXTDLGCTL, "WM_NEXTDLGCTL" },
	333	{ WM_SPOOLERSTATUS, "WM_SPOOLERSTATUS" },
	334	{ WM_DRAWITEM, "WM_DRAWITEM" },
	335	{ WM_MEASUREITEM, "WM_MEASUREITEM" },
	336	{ WM_DELETEITEM, "WM_DELETEITEM" },
	337	{ WM_VKEYTOITEM, "WM_VKEYTOITEM" },
	338	{ WM_CHARTOITEM, "WM_CHARTOITEM" },
	339	{ WM_SETFONT, "WM_SETFONT" },
	340	{ WM_GETFONT, "WM_GETFONT" },
	341	{ WM_SETHOTKEY, "WM_SETHOTKEY" },
	342	{ WM_GETHOTKEY, "WM_GETHOTKEY" },
	343	{ WM_QUERYDRAGICON, "WM_QUERYDRAGICON" },
	344	{ WM_COMPAREITEM, "WM_COMPAREITEM" },
	345	{ WM_COMPACTING, "WM_COMPACTING" },
	346	{ WM_WINDOWPOSCHANGING, "WM_WINDOWPOSCHANGING" },
	347	{ WM_WINDOWPOSCHANGED, "WM_WINDOWPOSCHANGED" },
	348	{ WM_POWER, "WM_POWER" },
	349	{ WM_COPYDATA, "WM_COPYDATA" },
	350	{ WM_CANCELJOURNAL, "WM_CANCELJOURNAL" },
	351	{ WM_NCCREATE, "WM_NCCREATE" },
	352	{ WM_NCDESTROY, "WM_NCDESTROY" },
	353	{ WM_NCCALCSIZE, "WM_NCCALCSIZE" },
	354	{ WM_NCHITTEST, "WM_NCHITTEST" },
355	{ WM_NCPAINT, "WM_NCPAINT" },
356	{ WM_NCACTIVATE, "WM_NCACTIVATE" },
357	{ WM_GETDLGCODE, "WM_GETDLGCODE" },
358	{ WM_NCMOUSEMOVE, "WM_NCMOUSEMOVE" },
359	{ WM_NCLBUTTONDOWN, "WM_NCLBUTTONDOWN" },
360	{ WM_NCLBUTTONUP, "WM_NCLBUTTONUP" },
361	{ WM_NCLBUTTONDBLCLK, "WM_NCLBUTTONDBLCLK" },
362	{ WM_NCRBUTTONDOWN, "WM_NCRBUTTONDOWN" },
363	{ WM_NCRBUTTONUP, "WM_NCRBUTTONUP" },
364	{ WM_NCRBUTTONDBLCLK, "WM_NCRBUTTONDBLCLK" },
365	{ WM_NCMBUTTONDOWN, "WM_NCMBUTTONDOWN" },
366	{ WM_NCMBUTTONUP, "WM_NCMBUTTONUP" },
367	{ WM_NCMBUTTONDBLCLK, "WM_NCMBUTTONDBLCLK" },
368	{ WM_KEYFIRST, "WM_KEYFIRST" },
369	{ WM_KEYDOWN, "WM_KEYDOWN" },
370	{ WM_KEYUP, "WM_KEYUP" },
371	{ WM_CHAR, "WM_CHAR" },
372	{ WM_DEADCHAR, "WM_DEADCHAR" },
373	{ WM_SYSKEYDOWN, "WM_SYSKEYDOWN" },
374	{ WM_SYSKEYUP, "WM_SYSKEYUP" },
375	{ WM_SYSCHAR, "WM_SYSCHAR" },
376	{ WM_SYSDEADCHAR, "WM_SYSDEADCHAR" },
377	{ WM_KEYLAST, "WM_KEYLAST" },
378	{ WM_INITDIALOG, "WM_INITDIALOG" },
379	{ WM_COMMAND, "WM_COMMAND" },
380	{ WM_SYSCOMMAND, "WM_SYSCOMMAND" },
381	{ WM_TIMER, "WM_TIMER" },
382	{ WM_HSCROLL, "WM_HSCROLL" },
383	{ WM_VSCROLL, "WM_VSCROLL" },
384	{ WM_INITMENU, "WM_INITMENU" },
385	{ WM_INITMENUPOPUP, "WM_INITMENUPOPUP" },
386	{ WM_MENUSELECT, "WM_MENUSELECT" },
387	{ WM_MENUCHAR, "WM_MENUCHAR" },
388	{ WM_ENTERIDLE, "WM_ENTERIDLE" },
389	{ WM_CTLCOLORMSGBOX, "WM_CTLCOLORMSGBOX" },
390	{ WM_CTLCOLOREDIT, "WM_CTLCOLOREDIT" },
391	{ WM_CTLCOLORLISTBOX, "WM_CTLCOLORLISTBOX" },
392	{ WM_CTLCOLORBTN, "WM_CTLCOLORBTN" },
393	{ WM_CTLCOLORDLG, "WM_CTLCOLORDLG" },
394	{ WM_CTLCOLORSCROLLBAR, "WM_CTLCOLORSCROLLBAR" },
395	{ WM_CTLCOLORSTATIC, "WM_CTLCOLORSTATIC" },
396	{ WM_MOUSEFIRST, "WM_MOUSEFIRST" },
397	{ WM_MOUSEMOVE, "WM_MOUSEMOVE" },
398	{ WM_LBUTTONDOWN, "WM_LBUTTONDOWN" },
399	{ WM_LBUTTONUP, "WM_LBUTTONUP" },
400	{ WM_LBUTTONDBLCLK, "WM_LBUTTONDBLCLK" },
401	{ WM_RBUTTONDOWN, "WM_RBUTTONDOWN" },
402	{ WM_RBUTTONUP, "WM_RBUTTONUP" },
403	{ WM_RBUTTONDBLCLK, "WM_RBUTTONDBLCLK" },
404	{ WM_MBUTTONDOWN, "WM_MBUTTONDOWN" },
405	{ WM_MBUTTONUP, "WM_MBUTTONUP" },
406	{ WM_MBUTTONDBLCLK, "WM_MBUTTONDBLCLK" },
407	{ WM_MOUSELAST, "WM_MOUSELAST" },
408	{ WM_PARENTNOTIFY, "WM_PARENTNOTIFY" },
409	{ WM_ENTERMENULOOP, "WM_ENTERMENULOOP" },
410	{ WM_EXITMENULOOP, "WM_EXITMENULOOP" },
411	{ WM_MDICREATE, "WM_MDICREATE" },
412	{ WM_MDIDESTROY, "WM_MDIDESTROY" },
413	{ WM_MDIACTIVATE, "WM_MDIACTIVATE" },
414	{ WM_MDIRESTORE, "WM_MDIRESTORE" },
415	{ WM_MDINEXT, "WM_MDINEXT" },
416	{ WM_MDIMAXIMIZE, "WM_MDIMAXIMIZE" },
417	{ WM_MDITILE, "WM_MDITILE" },
418	{ WM_MDICASCADE, "WM_MDICASCADE" },
419	{ WM_MDIICONARRANGE, "WM_MDIICONARRANGE" },
420	{ WM_MDIGETACTIVE, "WM_MDIGETACTIVE" },
421	{ WM_MDISETMENU, "WM_MDISETMENU" },
422	{ WM_DROPFILES, "WM_DROPFILES" },
423	{ WM_MDIREFRESHMENU, "WM_MDIREFRESHMENU" },
424	{ WM_CUT, "WM_CUT" },
425	{ WM_COPY, "WM_COPY" },
426	{ WM_PASTE, "WM_PASTE" },
427	{ WM_CLEAR, "WM_CLEAR" },
428	{ WM_UNDO, "WM_UNDO" },
429	{ WM_RENDERFORMAT, "WM_RENDERFORMAT" },
430	{ WM_RENDERALLFORMATS, "WM_RENDERALLFORMATS" },
431	{ WM_DESTROYCLIPBOARD, "WM_DESTROYCLIPBOARD" },
432	{ WM_DRAWCLIPBOARD, "WM_DRAWCLIPBOARD" },
433	{ WM_PAINTCLIPBOARD, "WM_PAINTCLIPBOARD" },
434	{ WM_VSCROLLCLIPBOARD, "WM_VSCROLLCLIPBOARD" },
435	{ WM_SIZECLIPBOARD, "WM_SIZECLIPBOARD" },
436	{ WM_ASKCBFORMATNAME, "WM_ASKCBFORMATNAME" },
437	{ WM_CHANGECBCHAIN, "WM_CHANGECBCHAIN" },
438	{ WM_HSCROLLCLIPBOARD, "WM_HSCROLLCLIPBOARD" },
439	{ WM_QUERYNEWPALETTE, "WM_QUERYNEWPALETTE" },
440	{ WM_PALETTEISCHANGING, "WM_PALETTEISCHANGING" },
441	{ WM_PALETTECHANGED, "WM_PALETTECHANGED" },
442	{ WM_HOTKEY, "WM_HOTKEY" },
443	{ WM_PENWINFIRST, "WM_PENWINFIRST" },
444	{ WM_PENWINLAST, "WM_PENWINLAST" },
445	{ WM_ASYNCIO, "ASYNCIO" },
446	{ 0, 0 }};
447
5abc9b83 CF	448	void
5abc9b83 CF	449	strace::wm (int message, int word, int lon)
1fd5e000	450	{
5d970405	451	if (active ())
1fd5e000 CF	452	{
	453	int i;
	454
	455	for (i = 0; ta[i].n; i++)
	456	{
	457	if (ta[i].v == message)
	458	{
335556d5	459	prntf (_STRACE_WM, NULL, "wndproc %d %s %d %d", message, ta[i].n, word, lon);
1fd5e000 CF	460	return;
	461	}
	462	}
335556d5	463	prntf (_STRACE_WM, NULL, "wndproc %d unknown %d %d", message, word, lon);
1fd5e000 CF	464	}
1fd5e000 CF	465	}
1fd5e000	466	#endif /NOSTRACE/