运行异常监控

 

只有非windows才启作用.linux异常监控

#ifndef ABTOR_WINDOWS
    initLinuxDump(logdir.c_str());
#endif

 

 

#pragma once

#ifndef ABTOR_WINDOWS

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include <signal.h>
#include <execinfo.h>

#include<sys/types.h>
#include<unistd.h>
#include<fcntl.h>

#include <pthread.h>
#include <sys/types.h>
#include <sys/syscall.h>
#include <string.h>

static int _core_dump_signals[] = {
    /*SIGABRT,*/SIGFPE, SIGILL, SIGQUIT, SIGSEGV,
    SIGTRAP, SIGSYS, SIGBUS, SIGXCPU, SIGXFSZ
#ifdef SIGEMT
    ,SIGEMT
#endif
};

static char g_log_dir[1024] = {0};



struct flock* file_lock(short type, short whence)
{
    static struct flock ret ;
    ret.l_type = type ;
    ret.l_start = 0 ;
    ret.l_whence = whence ;
    ret.l_len = 0 ;
    ret.l_pid = getpid() ;
    return &ret ;
}

void saveBackTrace(int signalno)
{

    char logFile[1024] = {0};
    FILE* fLog = NULL;
    sprintf(logFile,"%s/core.dump",g_log_dir);
    fLog = fopen(logFile,"w+");
    if(fLog == NULL)
    {
        return;
    }
    int fd = fileno(fLog);
    fcntl(fd, F_SETLKW, file_lock(F_WRLCK, SEEK_SET));

    char buffer[4096] = {0};
    int count = readlink("/proc/self/exe", buffer, 4096);
    if(count > 0)
    {
        buffer[count] = '\n';
        buffer[count + 1] = 0;
        fwrite(buffer, 1, count + 1, fLog);
        fflush(fLog);
    }


//#记录捕捉到的信号
    strcpy(buffer, "Catch signal: ");
    printf("Catch signal:%d\n",signalno);
    fflush(stdout);
    switch (signalno)
    {
        case SIGSEGV: strcat(buffer, "SIGSEGV\n");
            break;
        case SIGILL: strcat(buffer, "SIGILL\n");
            break;
        case SIGFPE: strcat(buffer, "SIGFPE\n");
            break;
        case SIGABRT: strcat(buffer, "SIGABRT\n");
            break;
        case SIGTERM: strcat(buffer, "SIGTERM\n");
            break;
        case SIGKILL: strcat(buffer, "SIGKILL\n");
            break;
        case SIGXFSZ: strcat(buffer, "SIGXFSZ\n");

            break;
        default: sprintf(buffer, "Catch signal: %d\n", signalno);
            break;
    }
    fwrite(buffer, 1, strlen(buffer), fLog);
    fflush(fLog);

//#打印一些全局变量。去掉这个信息的打印，因为每个crash的thread id号都不一样，不方便判断crash是否一样。
    printf("thread lwpid: %u\n", syscall(SYS_gettid));
//    sprintf(buffer, "thread lwpid: %u\n", syscall(SYS_gettid));
//    fwrite(buffer, 1, strlen(buffer), fLog);
//    fflush(fLog);
//    sprintf(buffer, "thread tid: %u\n", pthread_self());
    printf("thread tid: %u\n", pthread_self());
//    fwrite(buffer, 1, strlen(buffer), fLog);
//    fflush(fLog);

    printf("1\n");
    fflush(stdout);
//#打印堆栈信息
    void* DumpArray[256];
    int nSize = backtrace(DumpArray, 256);
    char** symbols = backtrace_symbols(DumpArray, nSize);
    printf("DumpArraySize:%d symbols:%p\n",nSize,symbols);
    if (symbols)
    {
        if (nSize > 256)
        {
            nSize = 256;
        }
        if (nSize > 0)
        {
#if 0
            //定位源代码行
            char cmd[264] = "addr2line -f -e ";
            char buff1[256] = { 0 }, buff2[1024] = { 0 }, buff3[256] = { 0 };
            char* prog = cmd + 16;
            readlink("/proc/self/exe", prog, sizeof(cmd) - (prog-cmd)-1);// 获取进程的完整路径
            int leftlen = strlen(cmd);
            prog = cmd + leftlen;
            leftlen = 263 - leftlen;
            for (size_t i = 0; i < nSize; ++i)
            {
                snprintf(prog, leftlen, " %p\n", DumpArray[i]);

                FILE* fp = popen(cmd, "r");
                if (fp != NULL)
                {
                    if (NULL != fgets(buff1, 255, fp))
                    {
//                        fgets(buff2, 1023, fp);
//                        if (buff2[strlen(buff2) - 1] == '\n')
//                            buff2[strlen(buff2) - 1] = 0;
                        if(buff1[0] == '\?')
                        {
                            fprintf(fLog, "%s\n",  symbols[i]+40);
                            printf("%s\n",  symbols[i]+40);
                        }
                        else
                        {
                            snprintf(buff3, 255, "c++filt %s\n", buff1);//用c++filt 使函数名可视化
                            FILE* fp2 = popen(buff3, "r");
                            if (fp2 && fgets(buff3, 255, fp2)) {
                                fprintf(fLog, "%s %s\n", prog, buff3);
                                printf("%s %s\n", prog, buff3);
                                fflush(fLog);
                                pclose(fp2);
                            }
                            else
                            {
                                fprintf(fLog, "%s %s\n", prog, buff1);
                                printf("%s %s\n", prog, buff1);
                                fflush(fLog);
                            }
                        }


                    }
                    pclose(fp);
                }
            }
#else
            for (int i = 0; i < nSize; i++)
            {
                fwrite(symbols[i], 1, strlen(symbols[i]), fLog);
                fwrite("\n", 1, 1, fLog);
                fflush(fLog);
                printf("%s\n",symbols[i]);
                fflush(stdout);
            }
#endif
        }
        free(symbols);
    }
    fcntl(fd, F_SETLK, file_lock(F_UNLCK, SEEK_SET));
    fclose(fLog);
    printf("2\n");
    fflush(stdout);

    signal(signalno, SIG_DFL);
    raise(signalno);
    exit(3);
}


void initLinuxDump(const char* logPath)
{
    //设置 信好的处理函数
    strcpy(g_log_dir, logPath);

    signal(SIGSEGV, saveBackTrace);
    for (int i = 0; i < (sizeof(_core_dump_signals) / sizeof((_core_dump_signals)[0])); i++)
    {
       signal(_core_dump_signals[i], saveBackTrace);
    }

    // block SIGINT to all child process:
    //sigset_t bset, oset;
    //sigemptyset(&bset);
    //sigaddset(&bset, SIGINT);
    // equivalent to sigprocmask
    //设置信号为阻塞信号
    //if (pthread_sigmask(SIG_BLOCK, &bset, &oset) != 0)
    {
       // printf("set thread signal mask error!");
    }

}


#endif