Changeset 9240 in orxonox.OLD for trunk/src/util

Timestamp:

Jul 6, 2006, 12:25:44 PM (18 years ago)

Author:

bensch

Message:

orxonox/trunk: better signal handler.
patched by chrigi

Location:

trunk/src/util

Files:

• signal_handler.cc (modified) (2 diffs)
• signal_handler.h (modified) (4 diffs)

trunk/src/util/signal_handler.cc

@@ -21 +21 @@
 #ifndef __WIN32__
 
+#include <wait.h>
+
 SignalHandler::SignalHandler()
 {
 }
 
-void SignalHandler::doCatch( std::string appName, GdbRunType type )
-{
-  this->type = type;
+void SignalHandler::doCatch( std::string appName )
+{
   this->appName = appName;
 
@@ -77 +78 @@
 
   printf( "recieved signal %s\ntry to write backtrace to file orxonox.backtrace\n", sigName.c_str() );
-
-  int fd[2];
-
-  assert( pipe(fd) != -1 );
-
-  int pid = fork();
-
-  assert( pid != -1 );
-
-
-  if ( pid == 0 )
+  
+  int sigPipe[2];
+  if ( pipe(sigPipe) == -1 )
+  {
+    perror("pipe failed!\n");
+    exit(EXIT_FAILURE);
+  }
+  
+  int sigPid = fork();
+
+  if ( sigPid == -1 )
+  {
+    perror("fork failed!\n");
+    exit(EXIT_FAILURE);
+  }
+
+  // gdb will be attached to this process
+  if ( sigPid == 0 )
   {
     getInstance()->dontCatch();
-    sleep(2);
+    // wait for message from parent when it has attached gdb
+    int someData;
+
+    read( sigPipe[0], &someData, sizeof(someData) );
+
+    if ( someData != 0x12345678 )
+    {
+      printf("something went wrong :(\n");
+    }
 
     return;
   }
-  else
-  {
-    getInstance()->dontCatch();
-    if ( getInstance()->type == GDB_RUN_WRITE_TO_FILE && fork() == 0 )
-    {
-      sleep(1);
-      write( fd[1], "c\nbt\nq\n", 7 );
-
-      exit(0);
-    }
-
-    char command[256];
-    if ( getInstance()->type == GDB_RUN_WRITE_TO_FILE )
-    {
-      dup2( fd[0], STDIN_FILENO );
-      snprintf( command, 255, "gdb -p %d %s 1>>" GDB_BT_FILE " 2>&1", pid, getInstance()->appName.c_str() );
-    }
-    else
-      snprintf( command, 255, "gdb -p %d %s", pid, getInstance()->appName.c_str() );
-    execlp( "sh", "sh", "-c", command, (void*)NULL);
-  }
+
+  int gdbIn[2];
+  int gdbOut[2];
+  int gdbErr[2];
+  
+  if ( pipe(gdbIn) == -1 || pipe(gdbOut) == -1 || pipe(gdbErr) == -1 )
+  {
+    perror("pipe failed!\n");
+    kill( sigPid, SIGTERM );
+    waitpid( sigPid, NULL, 0 );
+    exit(EXIT_FAILURE);
+  }
+
+  int gdbPid = fork();
+  // this process will run gdb
+  
+  if ( gdbPid == -1 )
+  {
+    perror("fork failed\n");
+    kill( sigPid, SIGTERM );
+    waitpid( sigPid, NULL, 0 );
+    exit(EXIT_FAILURE);
+  }
+  
+  if ( gdbPid == 0 )
+  {
+    // start gdb
+    
+    close(gdbIn[1]);
+    close(gdbOut[0]);
+    close(gdbErr[0]);
+
+    dup2( gdbIn[0], STDIN_FILENO );
+    dup2( gdbOut[1], STDOUT_FILENO );
+    dup2( gdbErr[1], STDERR_FILENO );
+    
+    execlp( "sh", "sh", "-c", "gdb", (void*)NULL);
+  }
+
+  char cmd[256];
+  snprintf( cmd, 256, "file %s\nattach %d\nc\n", getInstance()->appName.c_str(), sigPid );
+  write( gdbIn[1], cmd, strlen(cmd) );
+
+  int charsFound = 0;
+  int promptFound = 0;
+  char byte;
+  while ( read( gdbOut[0], &byte, 1 ) == 1 )
+  {
+    if ( 
+      charsFound == 0 && byte == '(' ||
+      charsFound == 1 && byte == 'g' ||
+      charsFound == 2 && byte == 'd' ||
+      charsFound == 3 && byte == 'b' ||
+      charsFound == 4 && byte == ')' ||
+      charsFound == 5 && byte == ' '
+        )
+          charsFound++;
+
+    if ( charsFound == 6 )
+    {
+      promptFound++;
+      charsFound = 0;
+    }
+
+    if ( promptFound == 3 )
+    {
+      break;
+    }
+  }
+  
+  int someData = 0x12345678;
+  write( sigPipe[1], &someData, sizeof(someData) );
+
+  write( gdbIn[1], "bt\nq\n", 5 );
+
+  
+  charsFound = 0;
+  promptFound = 0;
+  std::string bt;
+  while ( read( gdbOut[0], &byte, 1 ) == 1 )
+  {
+    bt += std::string( &byte, 1 );
+
+    if ( 
+      charsFound == 0 && byte == '(' ||
+      charsFound == 1 && byte == 'g' ||
+      charsFound == 2 && byte == 'd' ||
+      charsFound == 3 && byte == 'b' ||
+      charsFound == 4 && byte == ')' ||
+      charsFound == 5 && byte == ' '
+        )
+          charsFound++;
+
+    if ( charsFound == 6 )
+    {
+      promptFound++;
+      charsFound = 0;
+      bt += "\n";
+    }
+
+    if ( promptFound == 2 )
+    {
+      break;
+    }
+  }
+
+
+  waitpid( sigPid, NULL, 0 );
+  waitpid( gdbPid, NULL, 0 );
+  
+  int wsRemoved = 0;
+
+  while ( wsRemoved < 2 && bt.length() > 0 )
+  {
+    if ( bt[1] == '\n' )
+      wsRemoved++;
+    bt.erase(0, 1);
+  }
+
+  if ( bt.length() > 0 )
+    bt.erase(0, 1);
+
+  time_t now = time(NULL);
+
+  std::string timeString = "\n\n\n\n"
+                           "=======================================================\n"
+                           "= time: " + std::string(ctime(&now)) +
+                           "=======================================================\n";
+  bt.insert(0, timeString);
+  
+  FILE * f = fopen( GDB_BT_FILE, "a" );
+
+  if ( !f )
+  {
+    perror("could not append to " GDB_BT_FILE);
+    exit(EXIT_FAILURE);
+  }
+
+  if ( fwrite( bt.c_str(), 1, bt.length(), f ) != bt.length() )
+  {
+    printf("could not write %d byte to " GDB_BT_FILE, bt.length());
+    exit(EXIT_FAILURE);
+  }
+
+  exit(EXIT_FAILURE);
 }
 

trunk/src/util/signal_handler.h

@@ -12 +12 @@
 
 #define GDB_BT_FILE "orxonox.backtrace"
-enum GdbRunType{
-  GDB_RUN_WRITE_TO_FILE = 1,
-  GDB_RUN_IN_FOREGROUND
-};
 
 typedef int (*SignalCallback)( void * someData );
@@ -48 +44 @@
     void registerCallback( SignalCallback cb, void * someData );
 
-    void doCatch( std::string appName, GdbRunType type = GDB_RUN_WRITE_TO_FILE );
+    void doCatch( std::string appName );
     void dontCatch();
 
@@ -61 +57 @@
     static SignalHandler * singletonRef;
 
-    GdbRunType type;
-
     std::string appName;
 };
@@ -71 +65 @@
  public:
    inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; };
-  void doCatch( std::string appName, GdbRunType type = GDB_RUN_WRITE_TO_FILE ) {};
+  void doCatch( std::string appName ) {};
   void dontCatch() {};
   void registerCallback( SignalCallback cb, void * someData ) {};