hvirtual/guicast/bcsignals.C

   1 #include "bcsignals.h"
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5
   6 BC_Signals* BC_Signals::global_signals = 0;
   7 static int signal_done = 0;
   8
   9
  10 static char* signal_titles[] =
  11 {
  12         "NULL",
  13         "SIGHUP",
  14         "SIGINT",
  15         "SIGQUIT",
  16         "SIGILL",
  17         "SIGTRAP",
  18         "SIGABRT",
  19         "SIGBUS",
  20         "SIGFPE",
  21         "SIGKILL",
  22         "SIGUSR1",
  23         "SIGSEGV",
  24         "SIGUSR2",
  25         "SIGPIPE",
  26         "SIGALRM",
  27         "SIGTERM"
  28 };
  29
  30 static void signal_entry(int signum)
  31 {
  32
  33         if(signal_done)
  34         {
  35                 return;
  36         }
  37
  38         signal_done = 1;
  39
  40
  41
  42 // Dump trace table
  43         printf("signal_entry: got %s execution table:\n",
  44                 signal_titles[signum],
  45                 BC_Signals::global_signals->execution_table.total);
  46         if(BC_Signals::global_signals->execution_table.total)
  47         {
  48                 for(int i = 0; i < BC_Signals::global_signals->execution_table.total; i++)
  49                         printf("    %s\n", BC_Signals::global_signals->execution_table.values[i]);
  50         }
  51
  52 // Dump lock table
  53         printf("signal_entry: lock table\n",
  54                 BC_Signals::global_signals->lock_table.total);
  55         for(int i = 0; i < BC_Signals::global_signals->lock_table.total; i++)
  56         {
  57                 BC_LockTrace *table = BC_Signals::global_signals->lock_table.values[i];
  58                 if(table->is_lock)
  59                         printf("    %p %s %s\n",
  60                                 BC_Signals::global_signals->lock_table.values[i]->ptr,
  61                                 BC_Signals::global_signals->lock_table.values[i]->title,
  62                                 BC_Signals::global_signals->lock_table.values[i]->location);
  63         }
  64
  65         BC_Signals::global_signals->signal_handler(signum);
  66         signal(signum, SIG_DFL);
  67
  68
  69
  70 }
  71
  72 BC_Signals::BC_Signals()
  73 {
  74 }
  75
  76 void BC_Signals::initialize()
  77 {
  78         BC_Signals::global_signals = this;
  79         lock = new pthread_mutex_t;
  80         pthread_mutex_init(lock, 0);
  81         execution_table.set_array_delete();
  82
  83         signal(SIGHUP, signal_entry);
  84         signal(SIGINT, signal_entry);
  85         signal(SIGQUIT, signal_entry);
  86         signal(SIGKILL, signal_entry);
  87         signal(SIGSEGV, signal_entry);
  88         signal(SIGTERM, signal_entry);
  89         signal(SIGFPE, signal_entry);
  90 }
  91
  92
  93 void BC_Signals::signal_handler(int signum)
  94 {
  95 //      exit(0);
  96 }
  97
  98 char* BC_Signals::sig_to_str(int number)
  99 {
 100         return signal_titles[number];
 101 }
 102
 103 void BC_Signals::new_trace(char *text)
 104 {
 105         if(!global_signals) return;
 106         pthread_mutex_lock(global_signals->lock);
 107         global_signals->execution_table.append(text);
 108         pthread_mutex_unlock(global_signals->lock);
 109 }
 110
 111 void BC_Signals::delete_traces()
 112 {
 113         if(!global_signals) return;
 114         pthread_mutex_lock(global_signals->lock);
 115         global_signals->execution_table.remove_all();
 116         pthread_mutex_unlock(global_signals->lock);
 117 }
 118
 119 void BC_Signals::set_lock(void *ptr, char *title, char *location)
 120 {
 121         if(!global_signals) return;
 122         pthread_mutex_lock(global_signals->lock);
 123 // Take off previous unlock entry.  Without this, our table explodes.
 124         int got_it = 0;
 125         for(int i = 0; i < global_signals->lock_table.total; i++)
 126         {
 127                 BC_LockTrace *table = global_signals->lock_table.values[i];
 128                 if(table->ptr == ptr && !table->is_lock)
 129                 {
 130                         global_signals->lock_table.remove_object_number(i);
 131                         got_it = 1;
 132                         break;
 133                 }
 134         }
 135
 136 // Put new lock entry
 137         if(!got_it)
 138         {
 139                 BC_LockTrace *table = new BC_LockTrace(ptr, title, location, 1);
 140                 global_signals->lock_table.append(table);
 141         }
 142         pthread_mutex_unlock(global_signals->lock);
 143 }
 144
 145 void BC_Signals::unset_lock(void *ptr)
 146 {
 147         if(!global_signals) return;
 148         pthread_mutex_lock(global_signals->lock);
 149 // Take off previous lock entry
 150         int got_it = 0;
 151         for(int i = 0; i < global_signals->lock_table.total; i++)
 152         {
 153                 BC_LockTrace *table = global_signals->lock_table.values[i];
 154                 if(table->ptr == ptr && table->is_lock)
 155                 {
 156                         global_signals->lock_table.remove_object_number(i);
 157                         break;
 158                 }
 159         }
 160 // Put new unlock entry
 161         if(!got_it)
 162         {
 163                 BC_LockTrace *table = new BC_LockTrace(ptr, 0, 0, 0);
 164                 global_signals->lock_table.append(table);
 165         }
 166         pthread_mutex_unlock(global_signals->lock);
 167 }
 168
 169 void BC_Signals::unset_all_locks(void *ptr)
 170 {
 171         if(!global_signals) return;
 172         pthread_mutex_lock(global_signals->lock);
 173 // Take off previous lock entry
 174         int got_it = 0;
 175         for(int i = 0; i < global_signals->lock_table.total; i++)
 176         {
 177                 BC_LockTrace *table = global_signals->lock_table.values[i];
 178                 if(table->ptr == ptr)
 179                 {
 180                         global_signals->lock_table.remove_object_number(i);
 181                 }
 182         }
 183         pthread_mutex_unlock(global_signals->lock);
 184 }
 185
 186 BC_LockTrace::BC_LockTrace(void *ptr, char *title, char *location, int is_lock)
 187 {
 188         this->ptr = ptr;
 189         this->title = title;
 190         this->location = location;
 191         this->is_lock = is_lock;
 192 }
 193
 194 BC_LockTrace::~BC_LockTrace()
 195 {
 196 }
 197
 198
 199