Subversion Repositories openrisc_me

//####COPYRIGHTBEGIN####

//                                                                          

// ----------------------------------------------------------------------------

// Copyright (C) 1998, 1999, 2000 Red Hat, Inc.

//

// This program is part of the eCos host tools.

//

// This program is free software; you can redistribute it and/or modify it 

// under the terms of the GNU General Public License as published by the Free 

// Software Foundation; either version 2 of the License, or (at your option) 

// any later version.

// 

// This program is distributed in the hope that it will be useful, but WITHOUT 

// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 

// more details.

// 

// You should have received a copy of the GNU General Public License along with

// this program; if not, write to the Free Software Foundation, Inc., 

// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

//

// ----------------------------------------------------------------------------

//                                                                          

//####COPYRIGHTEND####

//===========================================================================

//===========================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):   sdf

// Contact(s):  sdf

// Date:                1998/08/11

// Version:             0.01

// Purpose:     

// Description: This is the implementation of the class which allows for spawning subprocesses

//

// Requires:    

// Provides:    

// See also:    

// Known bugs:  

// Usage:       

//

//####DESCRIPTIONEND####

//

//===========================================================================

#include "eCosTrace.h"

#include "Subprocess.h"

#ifdef _WIN32

  #include <tlhelp32.h>

  HINSTANCE CSubprocess::hInstLib1 = VER_PLATFORM_WIN32_NT==CSubprocess::GetPlatform()?LoadLibrary(_T("PSAPI.DLL")):LoadLibrary(_T("Kernel32.DLL")) ;

  HINSTANCE CSubprocess::hInstLib2 = VER_PLATFORM_WIN32_NT==CSubprocess::GetPlatform()?LoadLibrary(_T("NTDLL.DLL")):NULL;

#endif

//#define CloseHandle(x) TRACE(_T("CSubprocess::CloseHandle %x\n"),x);::CloseHandle(x)

const unsigned int CSubprocess::PROCESS_KILL_EXIT_CODE=0xCCFFCCFF;

CSubprocess::CSubprocess(bool bAutoDelete):

  m_pfnContinue(DefaultContinuationFunc),

  m_pContinuationFuncParam(0),

  m_bAutoDelete(bAutoDelete),

  m_bThreadTerminated(true),

  m_bVerbose(false),

  m_nExitCode(-1),

  m_idProcess(0),

  m_pLogparam(0),

  m_pfnLogfunc(0),

  m_bKillThread(false)

{

#ifdef _WIN32

  m_hProcess=0;

#endif

}

CSubprocess::~CSubprocess()

{

  Kill();

  if(!CeCosThreadUtils::WaitFor(m_bThreadTerminated,1000)){

    m_bKillThread=true;

    CeCosThreadUtils::WaitFor(m_bThreadTerminated);

  }

#ifdef _WIN32

  if(m_hProcess){

    CloseHandle(m_hProcess);

  }

#endif

}

bool CSubprocess::Run(LogFunc *pfnLog,void * pLogparam, LPCTSTR pszCmd,bool bBlock/*=true*/)

{

  bool rc;

  if(!m_bThreadTerminated){

    rc=false;

  } else {

    m_pfnLogfunc=pfnLog;

    m_pLogparam=pLogparam;

#ifdef _WIN32 

    // UNIX does it from the thread func.  WIN32 could too, but it's nice to know at the time 

    // of calling run whether the process is successfully created.

    if(m_hProcess){

      // Normally done in the dtor

      CloseHandle(m_hProcess);

    }

    rc=CreateProcess(pszCmd);

#else 

    m_strCmd=pszCmd;

    rc=true;

#endif

    if(rc){

      m_bKillThread=false;

      if(bBlock){

        // When using RunThread, the manipulation of this Boolean is taken care of.

        // Here we must do it ourselves.

        m_bThreadTerminated=false;

        ThreadFunc();

        m_bThreadTerminated=true;

      } else {

        CeCosThreadUtils::RunThread(SThreadFunc,this,&m_bThreadTerminated,String::SFormat(_T("subprocess %d read"),m_idProcess));

      }

    }

  }

  return rc;

}

#ifdef _WIN32

bool CSubprocess::CreateProcess(LPCTSTR pszCmdline)

{

  STARTUPINFO   si;                    // For CreateProcess call

  HANDLE        hrPipe,hwPipe,hwPipe2,m_hrPipeTemp,m_hwPipeTemp;

  // Create the anonymous pipe

  SECURITY_ATTRIBUTES saPipe;          // Security for anonymous pipe

  saPipe.nLength = sizeof(SECURITY_ATTRIBUTES);

  saPipe.lpSecurityDescriptor = NULL;

  saPipe.bInheritHandle = true;

  ::CreatePipe(&m_hrPipeTemp,&hwPipe,&saPipe,10240);

  // In most cases you can get away with using the same anonymous

  // pipe write handle for both the child's standard output and

  // standard error, but this may cause problems if the child app

  // explicitly closes one of its standard output or error handles. If

  // that happens, the anonymous pipe will close, since the child's

  // standard output and error handles are really the same handle. The

  // child won't be able to write to the other write handle since the

  // pipe is now gone, and parent reads from the pipe will return

  // ERROR_BROKEN_PIPE and child output will be lost. To solve this

  // problem, simply duplicate the write end of the pipe to create

  // another distinct, separate handle to the write end of the pipe.

  // One pipe write handle will serve as standard out, the other as

  // standard error. Now *both* write handles must be closed before the

  // write end of the pipe actually closes.

  ::DuplicateHandle(::GetCurrentProcess(),                      // Source process

    hwPipe,                     // Handle to duplicate

    ::GetCurrentProcess(),   // Destination process

    &hwPipe2,               // New handle, used as stderr by child 

    0,                     // New access flags - ignored since DUPLICATE_SAME_ACCESS

    true,                  // It's inheritable

    DUPLICATE_SAME_ACCESS);

  ::CreatePipe(&hrPipe,&m_hwPipeTemp,&saPipe,10240);

  // Create new output read handle and the input write handles, setting

  // the Properties to FALSE. Otherwise, the child inherits the

  // properties and, as a result, non-closeable handles to the pipes

  // are created.

  DuplicateHandle(GetCurrentProcess(),m_hrPipeTemp,

                       GetCurrentProcess(),

                       &m_hrPipe, // Address of new handle.

                       0,FALSE, // Make it uninheritable.

                       DUPLICATE_SAME_ACCESS);

  DuplicateHandle(GetCurrentProcess(),m_hwPipeTemp,

                       GetCurrentProcess(),

                       &m_hwPipe, // Address of new handle.

                       0,FALSE, // Make it uninheritable.

                       DUPLICATE_SAME_ACCESS);

  // Close inheritable copies of the handles we do not want to be inherited:

  CloseHandle(m_hrPipeTemp);

  CloseHandle(m_hwPipeTemp);

  memset(&si, 0, sizeof(si));

  si.cb = sizeof(si);

  si.hStdOutput = hwPipe;

  si.hStdError =  hwPipe2;

  si.hStdInput =  hrPipe;

  si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;

  si.wShowWindow = SW_SHOW;

  LPCTSTR pszDir;

  if(m_strDir.empty()){

    pszDir=NULL; // current directory

  } else {

    pszDir=m_strDir;

  }

  PROCESS_INFORMATION pi;

  String strCmd(pszCmdline);

  String strOrigpath;

  if(!m_strPath.empty()){

          int nSize=GetEnvironmentVariable(_T("PATH"), NULL, 0);

          if(nSize>0){

      GetEnvironmentVariable(_T("PATH"),strOrigpath.GetBuffer(nSize),nSize);

      strOrigpath.ReleaseBuffer();

      SetEnvironmentVariable(_T("PATH"),m_strPath);

    }

  }

  bool rc=(TRUE==::CreateProcess(NULL,strCmd.GetBuffer(),NULL,NULL,true,DETACHED_PROCESS|CREATE_NEW_PROCESS_GROUP,NULL,pszDir,&si,&pi));

  if(!m_strPath.empty()){

    SetEnvironmentVariable(_T("PATH"),strOrigpath);

  }

  m_nErr=GetLastError();

  strCmd.ReleaseBuffer();

  if(rc){

    m_idProcess=pi.dwProcessId;

    m_hProcess=pi.hProcess;

    if(m_bVerbose){

      Output(String::SFormat(_T("*** Process %d created \"%s\"\n"),m_idProcess,pszCmdline));

    }

    TRACE(String::SFormat(_T("Process %d created \"%s\"\n"),m_idProcess,pszCmdline));

    m_nExitCode=STILL_ACTIVE;

    CloseHandle(pi.hThread);

  } else {

    m_idProcess=0;

    if(m_bVerbose){

      Output(String::SFormat(_T("*** Failed to create process \"%s\" %s\n"),pszCmdline,(LPCTSTR)ErrorString()));

    }

    TRACE(String::SFormat(_T("Failed to create process \"%s\" %s\n"),pszCmdline,(LPCTSTR)ErrorString()));

    m_nExitCode=GetLastError();

    CloseHandle(m_hrPipe);m_hrPipe=INVALID_HANDLE_VALUE;

    CloseHandle(m_hwPipe);m_hwPipe=INVALID_HANDLE_VALUE;

  }

  CloseHandle(hrPipe);

  CloseHandle(hwPipe);

  CloseHandle(hwPipe2);

  return rc;

}

void CSubprocess::ThreadFunc()

{

  TRACE(_T("Reading from process %d\n"),m_idProcess);

  DWORD dwAvail;

  DWORD dwExitCode;

  while (!m_bKillThread && m_pfnContinue(m_pContinuationFuncParam) && ::PeekNamedPipe(m_hrPipe, NULL, 0, 0, &dwAvail, NULL)){

//TRACE(_T("P%d\n"),dwAvail);

    if(dwAvail){

      dwAvail=MIN(dwAvail,80); // Read a maximum of 80 characters at a time

      DWORD dwRead;

      char *buf=new char[dwAvail+1];

//TRACE(_T("R%d\n"),dwAvail);

      if(!::ReadFile(m_hrPipe, buf, dwAvail, &dwRead, NULL)){

        TRACE(_T("ReadFile returns false\n"));

        delete [] buf;

        break;

      }

      buf[dwRead]='\0';

      Output(String::CStrToUnicodeStr(buf));

      delete [] buf;

    }

    else if (!ProcessAlive())

    {

        TRACE(_T("m_bThreadTerminated=%d\n"),m_bThreadTerminated);

        break;

    }

    // Fix for hanging in an endless loop under Windows ME, by Bill Diehls <billabloke@yahoo.com>

    else if (::GetExitCodeProcess(m_hProcess, &dwExitCode) && dwExitCode!=STILL_ACTIVE)

    {

                break;

    }

    else

    {

      CeCosThreadUtils::Sleep(250);

    }

  }

  ::GetExitCodeProcess(m_hProcess, &dwExitCode);

  m_nExitCode=dwExitCode;

#ifdef _DEBUG

  String str;

  switch(dwExitCode){

    case STILL_ACTIVE:

      str=_T("still alive");

      if(m_bKillThread){

        str+=_T(" - requested to stop reading");

      }

      break;

    case PROCESS_KILL_EXIT_CODE:

      str=_T("killed");

      break;

    default:

      str.Format(_T("terminated rc=%d"),dwExitCode);

      break;

  }

  TRACE(_T("Finished reading from process %d (%s)\n"),m_idProcess,(LPCTSTR)str);

#endif

  CloseHandle(m_hrPipe);m_hrPipe=INVALID_HANDLE_VALUE;

  CloseHandle(m_hwPipe);m_hwPipe=INVALID_HANDLE_VALUE;

  if(m_bAutoDelete){

    m_bThreadTerminated=true; // or else the dtor will block

    delete this;

  }

}

#else // UNIX

bool CSubprocess::CreateProcess(LPCTSTR pszCmdline)

{

  m_idProcess=0;

  int fdchild=-1; // the file descriptor for the child (slave) half of the pseudo-tty pair

  // Get a free /dev/ptyp0 (master) and /dev/ttyp0 (slave) tty pair

  String strMasterTty,strChildTty;

  for(unsigned int c=0;c<64;c++){

    strMasterTty.Format("/dev/pty%c%x",'p'+c/16,c%16);

    m_tty=open(strMasterTty, O_RDWR | O_NOCTTY);

    if (-1!=m_tty) {

      strChildTty.Format("/dev/tty%c%x",'p'+c/16,c%16);

      fdchild = open(strChildTty, O_RDWR);

      if (-1==fdchild) {

        close(m_tty);

        m_tty=fdchild=-1;

      } else {

        VTRACE("opened %s - fd=%d\n",(LPCTSTR)strMasterTty,m_tty);

        break;

      }

    }

  }

  if(-1==m_tty){

    ERROR(_T("Failed to get a pty\n"));

    return false;

  }

  TRACE(_T("Master pty %s (fd %d) slave pty %s (fd %d)\n"),(LPCTSTR)strMasterTty,m_tty,(LPCTSTR)strChildTty,fdchild);

  m_idProcess=fork();

  switch (m_idProcess) {

    // Fork failed

    case -1:

      TRACE(_T("Failed to create process - %s\n"),strerror(errno));

      m_idProcess=0;

      break;

    case 0:

      // Process is created (we're the child)

      {

        // Close all descriptors except the slave side of the pseudo-terminal

        for (int fd = 0; fd < (int) sysconf(_SC_OPEN_MAX); fd++) {

          if(fd!=fdchild){

            close(fd);

          }

        }

        setsid();

        dup2(fdchild, 0);

        dup2(fdchild, 1);

        dup2(fdchild, 2);

        close(fdchild);

        if(!m_strDir.empty()){

          if(0!=chdir(m_strDir)){

            if(m_bVerbose){

              fprintf(stderr,_T("*** Failed to change directory to %s\n"),(LPCTSTR)m_strDir);

            }

            exit (5);

          }

        }

        if(m_bVerbose){

          fprintf(stderr,_T("*** Process %d created \"%s\"\n"),m_idProcess,pszCmdline);

        }

        StringArray ar;

        int argc=String(pszCmdline).Chop(ar,_TCHAR(' '),true);

        TCHAR **argv=new TCHAR *[1+argc];

        for(int i=0;i<argc;i++){

          argv[i]=new TCHAR[1+strlen(ar[i])];

          strcpy(argv[i],ar[i]);

        }

        argv[argc]=0;

        if(!m_strPath.empty()){

          _tputenv(String::SFormat(_T("PATH=%s"),(LPCTSTR)m_strPath));

        }

        _texecvp(argv[0], argv);

      }

      fprintf(stderr,"exec error - %s\n",strerror(errno));

      exit(4);

    default:

      // Process is created (we're the parent)

      TRACE(_T("Closing fd %d\n"),fdchild);

      close(fdchild);

      TRACE(_T("Forked to create process %s - process id <%d>\n"), pszCmdline, m_idProcess);

      break;

  }

  return 0!=m_idProcess;

}

void CSubprocess::ThreadFunc()

{

  if(!CreateProcess(m_strCmd)){

    ERROR(_T("Failed to create process for %s\n"),(LPCTSTR)m_strCmd);

  } else {

    fcntl(m_tty,F_SETFL,O_NONBLOCK);

    int rc;

    do {

      TCHAR buf[4096];

      rc=read(m_tty, buf, sizeof(buf)-1);

      if(rc>=0){

        buf[rc]='\0';

      }

      switch(rc){

        case -1:

          if(EAGAIN==errno){

            CeCosThreadUtils::Sleep(250);

          } else {

              goto Done;

          }

          break;

        case 0:

          goto Done;

          continue;

        default:

          buf[rc]=_TCHAR('\0');

          Output(String::CStrToUnicodeStr(buf));

          continue;

      }

    } while(!m_bKillThread && m_pfnContinue(m_pContinuationFuncParam));

Done:

    TRACE(_T("Closing fd %d\n"),m_tty);

    close (m_tty);

    switch(waitpid(m_idProcess,&m_nExitCode,WNOHANG));

  }

  if(m_bAutoDelete){

    delete this;

  }

}

#endif

void CSubprocess::Output (LPCTSTR psz)

{

  m_pfnLogfunc(m_pLogparam,psz);

}

void CSubprocess::Send(LPCTSTR str)

{

  char *psz=String(str).GetCString();

  int nToWrite=strlen(psz);

  const char *c=psz;

  do {

#ifdef _WIN32

    DWORD dwWritten;

    if(!::WriteFile(m_hwPipe,psz,nToWrite,&dwWritten,0)){

      break;

    }

#else

    int dwWritten = write(m_tty, c, nToWrite);

    if(-1==dwWritten){

      break;

    }

#endif

    nToWrite-=(int)dwWritten;

    c+=(int)dwWritten;

  } while (nToWrite>0);

  //::FlushFileBuffers(m_hwPipe);

  delete [] psz;

}

bool CSubprocess::Kill(bool bRecurse)

{

TRACE(_T("CSubprocess::Kill pid %d recurse=%d\n"),m_idProcess,bRecurse);

  PInfoArray arPinfo;

  bool rc=false;

  if(m_idProcess && -1!=m_idProcess){

    // Start of with the easy one:

    if(bRecurse) {

      // Need to gather this information before we orphan our grandchildren:

      PSExtract(arPinfo);

    }

#ifdef _WIN32

    if(m_hProcess){

      TRACE(_T("Terminate process %s\n"),(LPCTSTR)Name(m_idProcess));

      rc=(TRUE==::TerminateProcess(m_hProcess,PROCESS_KILL_EXIT_CODE));

      // dtor's (or subsequent Run's) responsibility to close the handle

    }

#else

    rc=(0==kill(m_idProcess,SIGTERM));

    int status;

    waitpid(m_idProcess,&status,WNOHANG);

#endif

    if(bRecurse) {

      // kill process *and* its children

      // FIXME: needs to be top-down

      for(int i=0;i<(signed)arPinfo.size();i++){

        if(arPinfo[i].IsChildOf(m_idProcess)){

#ifdef _WIN32

          // begin hack

          const String strName(Name(arPinfo[i].PID));

          if(_tcsstr(strName,_T("eCosTest")) || _tcsstr(strName,_T("cmd.EXE")) || _tcsstr(strName,_T("CMD.EXE")) || arPinfo[i].PID==(signed)GetCurrentProcessId()){

            continue;

          }

          // end hack

          HANDLE hProcess=::OpenProcess(PROCESS_TERMINATE,false,arPinfo[i].PID);

          if(hProcess){

            TRACE(_T("Terminate process %s\n"),(LPCTSTR)Name(arPinfo[i].PID));

            rc&=(TRUE==::TerminateProcess(hProcess,PROCESS_KILL_EXIT_CODE));

            CloseHandle(hProcess);

          } else {

            rc=false;

          }

#else

          rc&=(0==kill(arPinfo[i].PID,SIGTERM));

          int status;

          waitpid(arPinfo[i].PID,&status,WNOHANG);

#endif

        }

      }

    }

  }

  return rc;

}

Time CSubprocess::CpuTime(bool bRecurse) const

{

  Time t=0;

  // kill process *and* its children

  // FIXME: needs to be top-down

#ifdef _WIN32

  __int64 ftCreation,ftExit,ftKernel,ftUser;

  if(m_hProcess && ::GetProcessTimes (m_hProcess,(FILETIME *)&ftCreation,(FILETIME *)&ftExit,(FILETIME *)&ftKernel,(FILETIME *)&ftUser)){

    t+=Time((ftKernel+ftUser)/10000);

  }

  if(bRecurse){

    PInfoArray arPinfo;

    PSExtract(arPinfo);

    if(m_idProcess && -1!=m_idProcess){

      for(int i=0;i<(signed)arPinfo.size();i++){

        if(arPinfo[i].IsChildOf(m_idProcess)){

          t+=arPinfo[i].tCpu;

        }

      }

    }

  }

#else

  PInfoArray arPinfo;

  PSExtract(arPinfo);

  for(int i=0;i<(signed)arPinfo.size();i++){

    if(arPinfo[i].PID==m_idProcess || arPinfo[i].IsChildOf(m_idProcess)){

      t+=arPinfo[i].tCpu;

    }

  }

#endif

  return t;

}

#ifdef _WIN32

bool CSubprocess::PSExtract(CSubprocess::PInfoArray &arPinfo)

{

  bool rc=false;

  arPinfo.clear();

  // If Windows NT:

  switch(GetPlatform()) {

  case VER_PLATFORM_WIN32_NT:

    if(hInstLib1) {

      // Get procedure addresses.

      static BOOL (WINAPI *lpfEnumProcesses)( DWORD *, DWORD cb, DWORD * ) = (BOOL(WINAPI *)(DWORD *,DWORD,DWORD*))GetProcAddress( hInstLib1, "EnumProcesses" ) ;

      if( lpfEnumProcesses) {

        if(hInstLib2) {

          static DWORD (WINAPI *lpfNtQueryInformationProcess)( HANDLE, int, void *, DWORD, LPDWORD ) =

            (DWORD(WINAPI *)(HANDLE, int, void *, DWORD, LPDWORD)) GetProcAddress( hInstLib2,"NtQueryInformationProcess" ) ;

          if(lpfNtQueryInformationProcess){

            DWORD dwMaxPids=256;

            DWORD dwPidSize;

            DWORD *arPids = NULL ;

            do {

              delete [] arPids;

              arPids=new DWORD[dwMaxPids];

            } while(lpfEnumProcesses(arPids, dwMaxPids, &dwPidSize) && dwPidSize/sizeof(DWORD)==dwMaxPids) ;

            if(dwPidSize/sizeof(DWORD)<dwMaxPids){

              rc=true;

              for( DWORD dwIndex = 0 ; (signed)dwIndex < dwPidSize/sizeof(DWORD); dwIndex++ ) {

                // Regardless of OpenProcess success or failure, we

                // still call the enum func with the ProcID.

                DWORD pid=arPids[dwIndex];

                HANDLE hProcess=::OpenProcess( PROCESS_QUERY_INFORMATION, FALSE, pid );

                if (hProcess ) {

                  struct {

                    DWORD ExitStatus; // receives process termination status

                    DWORD PebBaseAddress; // receives process environment block address

                    DWORD AffinityMask; // receives process affinity mask

                    DWORD BasePriority; // receives process priority class

                    ULONG UniqueProcessId; // receives process identifier

                    ULONG InheritedFromUniqueProcessId; // receives parent process identifier

                  } pbi;

                  memset( &pbi, 0, sizeof(pbi));

                  DWORD retLen;