Mailing-List: contact cygwin-help AT cygwin DOT com; run by ezmlm
List-Subscribe: <mailto:cygwin-subscribe AT cygwin DOT com>
List-Archive: <http://sourceware.org/ml/cygwin/>
List-Post: <mailto:cygwin AT cygwin DOT com>
List-Help: <mailto:cygwin-help AT cygwin DOT com>, <http://sourceware.org/ml/#faqs>
Sender: cygwin-owner AT cygwin DOT com
Mail-Followup-To: cygwin AT cygwin DOT com
Delivered-To: mailing list cygwin AT cygwin DOT com
Mime-Version: 1.0 (Apple Message framework v618)
To: cygwin AT cygwin DOT com
Message-Id: <F22EAA9A-DEFD-11D8-9E70-003065BF83DA@users.sourceforge.net>
Content-Type: multipart/mixed; boundary=Apple-Mail-5-867978223
From: Timothy Wall <twall AT users DOT sourceforge DOT net>
Subject: Code to use ctrl-break to get a java stack dump
Date: Mon, 26 Jul 2004 08:18:47 -0400
X-Spam-Level: 
X-Spam-Checker-Version: SpamAssassin 2.63 (2004-01-11) on mail00.int.oculustech.com
X-Spam-Status: No, hits=-4.9 required=4.5 tests=BAYES_00 autolearn=ham version=2.63
Note-from-DJ: This may be spam

--Apple-Mail-5-867978223
Content-Transfer-Encoding: 7bit
Content-Type: text/plain;
	charset=US-ASCII;
	format=flowed

Since cygwin will kill a subprocess if you hit ctrl-break manually, 
I've written a little utility that allows you to send ctrl-break 
directly to the java process from any other console on the same 
machine.

Note that if java is invoked directly from the shell, cygwin gets the 
ctrl-break and still kills java, but I usually run my java invocations 
from a makefile target, which somehow allows this to work.

e.g.

test:
	if  /bin/true; then java -cp . MyClass; fi


make test

Then, from some other console:

./cbreak

Hopefully someone else will find this of use.  The process walking code 
was taken from some gnarly MS example;  I'm sure there's got to be a 
better way.  This probably only works on XP and later (haven't tried it 
elsewhere, but some of the system calls used are marked XP+ only).

T.


--Apple-Mail-5-867978223
Content-Transfer-Encoding: 7bit
Content-Type: application/octet-stream;
	x-unix-mode=0775;
	name="cbreak.cc"
Content-Disposition: attachment;
	filename=cbreak.cc


// required for w32 console functions (XP+)
#define _WIN32_WINNT 0x0501

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string>
#include <list>
#include <iostream>

#include <windows.h>
#include <tlhelp32.h>


//  Forward declarations:
std::list<PROCESSENTRY32> GetProcessEntries();
BOOL ListProcessModules( DWORD dwPID );
BOOL ListProcessThreads( DWORD dwOwnerPID );
void printError( TCHAR* msg );
extern "C" BOOL WINAPI AttachConsole(DWORD);
extern "C" DWORD WINAPI GetConsoleProcessList(LPDWORD,DWORD);

extern "C" int main(int argc, char** argv) {

  std::list<PROCESSENTRY32> processes = GetProcessEntries();

  DWORD currentID = GetCurrentProcessId();
  DWORD parentID;
  DWORD targetID;
  DWORD ids[100];

  printf("Current pid=0x%x\n", currentID);
  //DWORD count = GetConsoleProcessList(ids, sizeof(ids)/sizeof(ids[0]));
  //printf("%d processes share this console\n", count);

  std::list<PROCESSENTRY32>::const_iterator it;
  for(it=processes.begin();it != processes.end();it++) {
    PROCESSENTRY32 pe = *it;
    if (pe.th32ProcessID == currentID) {
      parentID = pe.th32ParentProcessID;
      printf("Parent pid=0x%x\n", parentID);
    }
    else if (strcasecmp(pe.szExeFile, "java.exe") == 0) {
      targetID = pe.th32ProcessID;
    }
  }

  for(it=processes.begin();it != processes.end();it++) {
    PROCESSENTRY32 pe32 = *it;
    if (pe32.th32ProcessID == targetID) {

      //printf("Found %s\n", pe32.szExeFile);
      //printf("PID=0x%lx\n", pe32.th32ProcessID);
      //printf("PPID=0x%lx\n", pe32.th32ParentProcessID);

      printf("%s, pid=0x%lx\n", pe32.szExeFile, pe32.th32ProcessID);
      printf("Attaching to console of java process\n");
      // Must free the current console or the attach fails
      FreeConsole();
      bool attached = AttachConsole((DWORD)pe32.th32ProcessID) != 0;
      if (attached) {
        printf("Console attach succeeded for 0x%x\n", currentID);
        if(!GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT, 0)) {
          printError("ctrl-break failed");
        }
        else {
          printf("ctrl-break sent\n");
        }
        printf("restoring console");
        FreeConsole();
      }
      // FIXME this doesn't work
      if (AttachConsole(parentID)) {
        printf("Console restored");
      }
      else {
        printError("restore failed");
        return GetLastError();
      }
    }
  }

  return 0;
}

std::list<PROCESSENTRY32> GetProcessEntries() {
  HANDLE hProcessSnap;
  HANDLE hProcess;
  PROCESSENTRY32 pe32;
  DWORD dwPriorityClass;
  std::list<PROCESSENTRY32> processes;

  // Take a snapshot of all processes in the system.
  hProcessSnap = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
  if( hProcessSnap == INVALID_HANDLE_VALUE )
  {
    printError( "CreateToolhelp32Snapshot (of processes)" );
    return processes;
  }

  // Set the size of the structure before using it.
  pe32.dwSize = sizeof( PROCESSENTRY32 );

  // Retrieve information about the first process,
  // and exit if unsuccessful
  if( !Process32First( hProcessSnap, &pe32 ) )
  {
    printError( "Process32First" );  // Show cause of failure
    CloseHandle( hProcessSnap );     // Must clean up the snapshot object!
    return processes;
  }

  // Now walk the snapshot of processes, and
  // display information about each process in turn

  do
  {
    /*
    printf( "\n\n=====================================================" );
    printf( "\nPROCESS NAME:  %s", pe32.szExeFile );
    printf( "\n-----------------------------------------------------" );
    */
    // Retrieve the priority class.
    dwPriorityClass = 0;
    hProcess = OpenProcess( PROCESS_ALL_ACCESS, FALSE, pe32.th32ProcessID );
    if( hProcess == NULL ) {
      /*
      std::cerr << "Can't open process: " << pe32.szExeFile << std::endl;
      printError( "OpenProcess" );
      */
    }
    else
    {
      processes.push_back(pe32);
      dwPriorityClass = GetPriorityClass( hProcess );
      if( !dwPriorityClass )
        printError( "GetPriorityClass" );
      CloseHandle( hProcess );
    }

    /*
    printf( "\n  process ID        = 0x%08X", pe32.th32ProcessID );
    printf( "\n  thread count      = %d",   pe32.cntThreads );
    printf( "\n  parent process ID = 0x%08X", pe32.th32ParentProcessID );
    printf( "\n  Priority Base     = %d", pe32.pcPriClassBase );
    if( dwPriorityClass )
      printf( "\n  Priority Class    = %d", dwPriorityClass );

    // List the modules and threads associated with this process
    ListProcessModules( pe32.th32ProcessID );
    ListProcessThreads( pe32.th32ProcessID );
    */

  } while( Process32Next( hProcessSnap, &pe32 ) );

  // Don't forget to clean up the snapshot object!
  CloseHandle( hProcessSnap );

  return processes;
}


BOOL ListProcessModules( DWORD dwPID )
{
  HANDLE hModuleSnap = INVALID_HANDLE_VALUE;
  MODULEENTRY32 me32;

  // Take a snapshot of all modules in the specified process.
  hModuleSnap = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, dwPID );
  if( hModuleSnap == INVALID_HANDLE_VALUE )
  {
    printError( "CreateToolhelp32Snapshot (of modules)" );
    return( FALSE );
  }

  // Set the size of the structure before using it.
  me32.dwSize = sizeof( MODULEENTRY32 );

  // Retrieve information about the first module,
  // and exit if unsuccessful
  if( !Module32First( hModuleSnap, &me32 ) )
  {
    printError( "Module32First" );  // Show cause of failure
    CloseHandle( hModuleSnap );     // Must clean up the snapshot object!
    return( FALSE );
  }

  // Now walk the module list of the process,
  // and display information about each module
  do
  {
    printf( "\n\n     MODULE NAME:     %s",             me32.szModule );
    printf( "\n     executable     = %s",             me32.szExePath );
    printf( "\n     process ID     = 0x%08X",         me32.th32ProcessID );
    printf( "\n     ref count (g)  =     0x%04X",     me32.GlblcntUsage );
    printf( "\n     ref count (p)  =     0x%04X",     me32.ProccntUsage );
    printf( "\n     base address   = 0x%08X", (DWORD) me32.modBaseAddr );
    printf( "\n     base size      = %d",             me32.modBaseSize );

  } while( Module32Next( hModuleSnap, &me32 ) );

  // Don't forget to clean up the snapshot object.
  CloseHandle( hModuleSnap );
  return( TRUE );
}

BOOL ListProcessThreads( DWORD dwOwnerPID ) 
{ 
  HANDLE hThreadSnap = INVALID_HANDLE_VALUE; 
  THREADENTRY32 te32; 
 
  // Take a snapshot of all running threads  
  hThreadSnap = CreateToolhelp32Snapshot( TH32CS_SNAPTHREAD, 0 ); 
  if( hThreadSnap == INVALID_HANDLE_VALUE ) 
    return( FALSE ); 
 
  // Fill in the size of the structure before using it. 
  te32.dwSize = sizeof(THREADENTRY32 ); 
 
  // Retrieve information about the first thread,
  // and exit if unsuccessful
  if( !Thread32First( hThreadSnap, &te32 ) ) 
  {
    printError( "Thread32First" );  // Show cause of failure
    CloseHandle( hThreadSnap );     // Must clean up the snapshot object!
    return( FALSE );
  }

  // Now walk the thread list of the system,
  // and display information about each thread
  // associated with the specified process
  do 
  { 
    if( te32.th32OwnerProcessID == dwOwnerPID )
    {
      printf( "\n");
      printf( "     THREAD ID      = 0x%08X\n", te32.th32ThreadID ); 
      printf( "     base priority  = %d\n", te32.tpBasePri ); 
      printf( "     delta priority = %d\n", te32.tpDeltaPri ); 
    }
  } while( Thread32Next(hThreadSnap, &te32 ) ); 

  // Don't forget to clean up the snapshot object.
  CloseHandle( hThreadSnap );
  return( TRUE );
}

void printError( TCHAR* msg )
{
  DWORD eNum;
  TCHAR sysMsg[256];
  TCHAR* p;

  eNum = GetLastError( );
  FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
         NULL, eNum,
         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
         sysMsg, 256, NULL );

  // Trim the end of the line and terminate it with a null
  p = sysMsg;
  while( ( *p > 31 ) || ( *p == 9 ) )
    ++p;
  do { *p-- = 0; } while( ( p >= sysMsg ) &&
                          ( ( *p == '.' ) || ( *p < 33 ) ) );

  // Display the message
  printf( "WARNING: %s failed with error %d (%s)\n", msg, eNum, sysMsg );
}

--Apple-Mail-5-867978223
Content-Transfer-Encoding: 7bit
Content-Type: text/plain;
	charset=US-ASCII;
	format=flowed





--Apple-Mail-5-867978223
Content-Type: text/plain; charset=us-ascii

--
Unsubscribe info:      http://cygwin.com/ml/#unsubscribe-simple
Problem reports:       http://cygwin.com/problems.html
Documentation:         http://cygwin.com/docs.html
FAQ:                   http://cygwin.com/faq/
--Apple-Mail-5-867978223--