打印函数调用堆栈

static struct {
char *name;
int signum;
int flags; // 0: default handler, >0: catch, <0: ignore
} sig_table[] = {
{"zero", 0, 0 },
{"SIGHUP", SIGHUP, -1},
{"SIGINT", SIGINT, 1},
{"SIGQUIT", SIGQUIT, -1},
{"SIGILL", SIGILL, 1},
{"SIGTRAP", SIGTRAP, -1},
{"SIGABRT", SIGABRT, 1},
{"SIGBUS", SIGBUS, 1},
{"SIGFPE", SIGFPE, -1},
{"SIGKILL", SIGKILL, 0}, // reserved
{"SIGUSR1", SIGUSR1, 2}, // for light flicker
{"SIGSEGV", SIGSEGV, 1},
{"SIGUSR2", SIGUSR2, -1},
{"SIGPIPE", SIGPIPE, -1},
{"SIGALRM", SIGALRM, -1},
{"SIGTERM", SIGTERM, 1}, // for kill
{"SIGSTKFLT", SIGSTKFLT, -1},
//{"SIGCHLD", SIGCHLD, -1},
{"SIGCONT", SIGCONT, -1},
{"SIGSTOP", SIGSTOP, 0}, // reserved
{"SIGTSTP", SIGTSTP, -1},
{"SIGTTIN", SIGTTIN, -1},
{"SIGTTOU", SIGTTOU, -1},
{"SIGURG", SIGURG, -1},
{"SIGXCPU", SIGXCPU, -1},
{"SIGXFSZ", SIGXFSZ, -1},
{"SIGVTALRM", SIGVTALRM, -1},
{"SIGPROF", SIGPROF, -1},
{"SIGWINCH", SIGWINCH, -1},
{"SIGIO", SIGIO, -1},
{"SIGPWR", SIGPWR, -1},
{"SIGSYS", SIGSYS, -1},
};




#if 0
void dump(int signo)
{
char buf[1024];
char cmd[1024];
FILE *fp=NULL;
snprintf(buf,sizeof(buf),"/proc/%d/cmdline",getpid());
if(!(fp=fopen(buf,"r")))
{
return;
}
if(!(fgets(buf,sizeof(buf),fp)))
{
return;
}
fclose(fp);
if(buf[strlen(buf)-1]=='\n')
buf[strlen(buf)-1]='\0';
snprintf(cmd,sizeof(cmd),"gdb %s %d",buf,getpid());
printf("\n dump buf==%s\n",buf);
system(cmd);
}
#else
void dump(int signo)
{
void *array[30]={0};
size_t size=0,i=0;
char** strings=NULL;
printf("\n dump----1\n");
size=backtrace(array,30);
printf("\n dump----2 size==%d\n",size);
strings=backtrace_symbols(array,size);
printf("Obtained %d stackframes.\n",size);
for(i=0;i<size;i++)
{
printf("%s\n",strings[i]);
FunUserLog(strings[i],strlen(strings[i]));
}
free(strings);
}


#endif
static void signalHandler1(int signum)
{
if ((signum > 0) && (signum <= SIGSYS)) {
MainDebug("stop app on signal %s(%d)\n", sig_table[signum].name, signum);
} else {
MainDebug("stop app on error(%d)\n", signum);
}
if(signum ==SIGSEGV)
{
printf("\n programme recv SIGSEGV\n");
char *buf="programme recv SIGSEGV";
FunUserLog(buf,strlen(buf));
dump(SIGSEGV);
//sleep(5);
}
gblSetQuit();
exit(0);
}


static void signalHandler2(int signum)
{
if(!light_state)
{
light_state = 1;
}
return;
}




/*
 * setup_signal_handlers - set simple process signal processing policy.
*/
static void setup_signal_handlers(void)
{
int entry;
struct sigaction sigsetup;


// set proc signal handler
for (entry = 0; entry < sizeof(sig_table) / sizeof(sig_table[0]); entry++) {
memset(&sigsetup, 0, sizeof(sigsetup));
sigemptyset(&sigsetup.sa_mask);
sigsetup.sa_flags = 0;

// exit on system signal
if (sig_table[entry].flags == 1)
{
sigsetup.sa_handler = signalHandler1;
sigaction(sig_table[entry].signum, &sigsetup, NULL);
}


// exit on module signal
if (sig_table[entry].flags == 2)
{
sigsetup.sa_handler = signalHandler2;
sigaction(sig_table[entry].signum, &sigsetup, NULL);
}


// ignore these
if (sig_table[entry].flags < 0) {
sigsetup.sa_handler = SIG_IGN;
sigaction(sig_table[entry].signum, &sigsetup, NULL);
}
// default to others
}
}