日韩无码专区AV影音,欧美又硬又爽草逼视频,日本免费1区2区

前言

源碼:
https://github.com/Peakmain/Video_Audio/blob/master/app/src/main/java/com/peakmain/video_audio/utils/CrashUtils.kt
參考文章
騰訊bugly的Android 平臺 Native 代碼的崩潰捕獲機制及實現(xiàn)

native異常捕獲其實一直是個難點，也是一個大頭，在現(xiàn)在已有的方案呢，有的代碼量太大，有的存在兼容性問題等。騰訊bugly文章其實寫的已經(jīng)很明白了，一些東西知識我就拿過來用了，大家主要看代碼。

信號機制

異常發(fā)生時，CPU通過異常中斷的方式，觸發(fā)異常處理流程。不同的處理器，有不同的異常中斷類型和中斷處理方式
linux把這些中斷處理，統(tǒng)一為信號量，可以注冊信號量向量進行處理
所以簡單來說，native的異常捕獲，主要通過捕獲信號量

信號機制
函數(shù)運行在用戶態(tài)，當遇到系統(tǒng)調(diào)用、中斷或是異常的情況時，程序會進入內(nèi)核態(tài)。信號涉及到了這兩種狀態(tài)之間的轉(zhuǎn)換

image.png

常見信號類型

image.png

所以我們可以列出所有異常信號量

// 異常信號量
const int exceptionSignals[] = {SIGSEGV, SIGABRT, SIGFPE, SIGILL, SIGBUS, SIGTRAP};
const int exceptionSignalsNumber = sizeof(exceptionSignals)/ sizeof(exceptionSignals[0]);
//舊信號量 NSIG數(shù)量是65
static struct sigaction oldHandlers[NSIG];

捕捉信號量

注冊信號處理函數(shù)捕獲native異常
主要方法是

 int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact));

signum：代表信號編碼，可以是除SIGKILL及SIGSTOP外的任何一個特定有效的信號，如果為這兩個信號定義自己的處理函數(shù)，將導致信號安裝錯誤。
act：指向結構體sigaction的一個實例的指針，該實例指定了對特定信號的處理，如果設置為空，進程會執(zhí)行默認處理。
oldact：和參數(shù)act類似，只不過保存的是原來對相應信號的處理，也可設置為NULL。
因此我們就可以來捕獲native異常了

void signalPass(int code, siginfo_t *si, void *sc) {
    LOGE("監(jiān)聽到了native異常");
    // 這里要考慮非信號方式防止死鎖
    signal(code, SIG_DFL);
    signal(SIGALRM, SIG_DFL);
    (void) alarm(8);
    // 解析棧信息，回調(diào)給 java 層，上報到后臺或者保存本地文件
    notifyCaughtSignal(code, si, sc);
    // 給系統(tǒng)原來默認的處理，否則就會進入死循環(huán)
    oldHandlers[code].sa_sigaction(code, si, sc);
}

/**
 * 安裝信號捕獲到native crash
 */
bool installSignalHandlers() {
    //保存原來的信號處理
    for (int i = 0; i < exceptionSignalsNumber; i++) {
        // signum：代表信號編碼，可以是除SIGKILL及SIGSTOP外的任何一個特定有效的信號，如果為這兩個信號定義自己的處理函數(shù)，將導致信號安裝錯誤。
        // act：指向結構體sigaction的一個實例的指針，該實例指定了對特定信號的處理，如果設置為空，進程會執(zhí)行默認處理。
        // oldact：和參數(shù)act類似，只不過保存的是原來對相應信號的處理，也可設置為NULL。
        // int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact));
        if (sigaction(exceptionSignals[i], NULL, &oldHandlers[exceptionSignals[i]]) == -1) {
            return false;
        }
    }
    struct sigaction sa{};
    memset(&sa, 0, sizeof(sa));
    //不同堆棧處理并且可將參數(shù)傳遞下去
    sa.sa_flags = SA_ONSTACK | SA_SIGINFO;
    // 指定信號處理的回調(diào)函數(shù)
    sa.sa_sigaction = signalPass;
    //處理當前信號量的時候不考慮其他的
    for (int i = 0; i < exceptionSignalsNumber; ++i) {
        //阻塞其他信號的
        sigaddset(&sa.sa_mask, exceptionSignals[i]);
    }
    for (int i = 0; i < exceptionSignalsNumber; ++i) {
        //處理自己的信號，如果成功返回0，失敗返回-1
        if (sigaction(exceptionSignals[i], &sa, NULL) == -1) {
            // 可以輸出一個警告
        }
    }
    return true;
}

signalPass是我們自己指定的信號量去處理的回調(diào)函數(shù)。在這里我們需要注意防止信號死循環(huán)的狀態(tài)或者死鎖

  signal(code, SIG_DFL);
    signal(SIGALRM, SIG_DFL);
    (void) alarm(8);

設置額外的?？臻g

SIGSEGV很有可能是棧溢出引起的，如果在默認的棧上運行很有可能會破壞程序運行的現(xiàn)場，無法獲取到正確的上下文。而且當棧滿了（太多次遞歸，棧上太多對象），系統(tǒng)會在同一個已經(jīng)滿了的棧上調(diào)用SIGSEGV的信號處理函數(shù)，又再一次引起同樣的信號。
我們應該開辟一塊新的空間作為運行信號處理函數(shù)的棧。使用sigaltstack在任意線程注冊一個可選的棧，保留一下在緊急情況下使用的空間。
主要方法是

int sigaltstack(const stack_t* __new_signal_stack, stack_t* __old_signal_stack);

完整代碼

void installAlternateStack() {
    stack_t newStack;
    stack_t oldStack;
    memset(&newStack, 0, sizeof(newStack));
    memset(&oldStack, 0, sizeof(oldStack));
    static const unsigned sigaltstackSize = std::max(16384, SIGSTKSZ);
    if (sigaltstack(NULL, &oldStack) == -1
        || !oldStack.ss_sp
        || oldStack.ss_size < sigaltstackSize) {
        newStack.ss_sp = calloc(1, sigaltstackSize);
        newStack.ss_size = sigaltstackSize;
        if (sigaltstack(&newStack, NULL) == -1) {
            free(newStack.ss_sp);
        }
    }
}

分析堆棧

子線程實現(xiàn)分析堆棧，設計到的方法是pthread_create,并且我們需要將結果回調(diào)給Java

  //獲取全局的jvm
    JavaVM *javaVm;
    env->GetJavaVM(&javaVm);
    //生成全局對象
    callback = env->NewGlobalRef(callback);
    jclass nativeCrashMonitorClass = env->GetObjectClass(nativeCrashMonitor);
    nativeCrashMonitorClass = (jclass) env->NewGlobalRef(nativeCrashMonitorClass);
    auto *jniBridge = new JNIBridge(javaVm, callback, nativeCrashMonitorClass);
    pthread_t pthread;
    //創(chuàng)建一個線程
    initCondition();
    //ret=0代表創(chuàng)建成功
    int ret = pthread_create(&pthread, NULL, threadCrashMonitor, jniBridge);
    if (ret < 0) {
        LOGE("%s", "pthread_create error");
    }

我們可能會有多線程的存在，所以我們需要互斥鎖

//鎖的條件變量
pthread_cond_t signalCond;
pthread_mutex_t signalLock;
pthread_cond_t exceptionCond;
pthread_mutex_t exceptionLock;

void initCondition() {
    handlerContext = (native_handler_context *) malloc(sizeof(native_handler_context_struct));
    pthread_mutex_init(&signalLock, NULL);
    pthread_cond_init(&signalCond, NULL);
    pthread_mutex_init(&exceptionLock, NULL);
    pthread_cond_init(&exceptionCond, NULL);
}

pthread_create方法會將第四個參數(shù)傳給第三個方法作為參數(shù)

void *threadCrashMonitor(void *argv) {
    JNIBridge *jniBridge = static_cast<JNIBridge *>(argv);

    while (true) {
        //等待信號處理函數(shù)喚醒
        waitForSignal();
        //喚醒之后，分析native堆棧
        analysisNativeException();

        //拋給java
        jniBridge->throwException2Java(handlerContext);
    }
}

等待信號喚醒

//等待信號
void waitForSignal() {
    pthread_mutex_lock(&signalLock);
    LOGE("waitForSignal start.");
    pthread_cond_wait(&signalCond, &signalLock);
    LOGE("waitForSignal finish.");
    pthread_mutex_unlock(&signalLock);

}

既然有等待肯定會喚醒

void notifyCaughtSignal(int code, siginfo_t *si, void *sc) {
    copyInfo2Context(code, si, sc);
    pthread_mutex_lock(&signalLock);
    pthread_cond_signal(&signalCond);
    pthread_mutex_unlock(&signalLock);
}

保存喚醒后的信號信息和分析native異常

//保存喚醒后的信息
void copyInfo2Context(int code, siginfo_t *si, void *sc) {
    handlerContext->code = code;
    handlerContext->si = si;
    handlerContext->sc = sc;
    handlerContext->pid = getpid();
    handlerContext->tid = gettid();
    handlerContext->processName = getProcessName(handlerContext->pid);
    if (handlerContext->pid == handlerContext->tid) {
        handlerContext->threadName = "main";
    } else {
        handlerContext->threadName = getThreadName(handlerContext->tid);
    }
    handlerContext->frame_size = 0;
    //捕獲c/c++的堆棧信息
    _Unwind_Backtrace(unwind_callback, handlerContext);
}
//分析native的異常
void analysisNativeException() {
    const char *posixDesc = desc_sig(handlerContext->si->si_signo, handlerContext->si->si_code);
    LOGD("posixDesc -> %s", posixDesc);
    LOGD("signal -> %d", handlerContext->si->si_signo);
    LOGD("address -> %p", handlerContext->si->si_addr);
    LOGD("processName -> %s", handlerContext->processName);
    LOGD("threadName -> %s", handlerContext->threadName);
    LOGD("pid -> %d", handlerContext->pid);
    LOGD("tid -> %d", handlerContext->tid);
}

捕獲c/c++的堆棧信息,主要方法是

_Unwind_Backtrace(unwind_callback, handlerContext);

unwind_callback回調(diào)方法
handlerContext:參數(shù),并返回給unwind_callback作為參數(shù)

_Unwind_Reason_Code unwind_callback(struct _Unwind_Context *context, void *arg) {
    native_handler_context *const s = static_cast<native_handler_context *const>(arg);
    //pc是每個堆棧的棧頂
    const uintptr_t pc = _Unwind_GetIP(context);
    if (pc != 0x0) {
        // 把 pc 值保存到 native_handler_context
        s->frames[s->frame_size++] = pc;
    }
    if (s->frame_size == BACKTRACE_FRAMES_MAX) {
        return _URC_END_OF_STACK;
    } else {
        return _URC_NO_REASON;
    }
}

pc值是程序加載到內(nèi)存中的絕對地址

將native信息拋給Java

我們需要拿到奔潰代碼相對于共享庫的相對偏移地址。這時候通過dladdr()可以獲得共享庫加載到內(nèi)存的起始地址，和pc值相減就可以獲得相對偏移地址，并且可以獲得共享庫的名字。

Dl_info info;  
if (dladdr(addr, &info) != 0 && info.dli_fname != NULL) {  
  void * const nearest = info.dli_saddr;  
  //相對偏移地址
  const uintptr_t addr_relative =  
    ((uintptr_t) addr - (uintptr_t) info.dli_fbase);  
}

完整代碼

void JNIBridge::throwException2Java(native_handler_context *handlerContext) {
    LOGE("throwException2Java");
    //子線程獲取env
    JNIEnv *env = NULL;
    if (this->javaVm->AttachCurrentThread(&env, NULL) != JNI_OK) {
        LOGE("AttachCurrentThread failed");
    }
    const char *sig = "(Ljava/lang/String;)Ljava/lang/String;";
    jmethodID getStackInfoByThreadNameMid = env->GetStaticMethodID(this->nativeCrashMonitorClass,
                                                                   "getStackInfoByThreadName", sig);
    //private stifatic String getStackInfoByThreadName(String threadName)
    jstring jThreadName = env->NewStringUTF(handlerContext->threadName);
    jobject javaStackInfo = env->CallStaticObjectMethod(this->nativeCrashMonitorClass,
                                                        getStackInfoByThreadNameMid, jThreadName);
    //java的String->native的string
    const char *javaExceptionStackInfo = env->GetStringUTFChars((jstring) javaStackInfo, JNI_FALSE);
    //獲取c++堆棧信息
    int frame_size = handlerContext->frame_size;
    string result;
    for (int index = 0; index < frame_size; ++index) {
        uintptr_t pc = handlerContext->frames[index];
        //獲取到加載的內(nèi)存的起始地址
        Dl_info stack_info;
        void *const addr = (void *) pc;
        if (dladdr(addr, &stack_info) != 0 && stack_info.dli_fname != NULL) {

            if (stack_info.dli_fbase == 0) {
                // No valid map associated with this frame.
                result += "  <unknown>";
            } else if (stack_info.dli_fname) {
                std::string so_name = std::string(stack_info.dli_fname);
                result += "  " + so_name;
            } else {
                result += android::base::StringPrintf("  <anonymous:%" PRIx64 ">",
                                                      (uint64_t) stack_info.dli_fbase);
            }
            if (stack_info.dli_sname) {
                char *demangled_name = abi::__cxa_demangle(stack_info.dli_sname, nullptr, nullptr,
                                                           nullptr);
                if (demangled_name == nullptr) {
                    result += " (";
                    result += stack_info.dli_sname;
                } else {
                    result += " (";
                    result += demangled_name;
                    free(demangled_name);
                }
                if (stack_info.dli_saddr != 0) {
                    uintptr_t offset = pc - (uintptr_t) stack_info.dli_saddr;
                    result += android::base::StringPrintf("+%" PRId64, (uint64_t) offset);
                }
                result += ')';
            }
            result += '\n';
        }
    }
    //回掉Java的接口
    jclass crashClass = env->GetObjectClass(this->callbackObj);
    jmethodID crashMethod = env->GetMethodID(crashClass, "onCrash",
                                             "(Ljava/lang/String;Ljava/lang/Error;)V");
    jclass jErrorClass = env->FindClass("java/lang/Error");
    jmethodID jErrorInitMethod = env->GetMethodID(jErrorClass, "<init>", "(Ljava/lang/String;)V");
    result = result += javaExceptionStackInfo;
    jstring errorMessage = env->NewStringUTF(result.c_str());
    //錯誤信息給Error
    jobject errorObject = env->NewObject(jErrorClass, jErrorInitMethod, errorMessage);
    env->CallVoidMethod(this->callbackObj, crashMethod, jThreadName, errorObject);
    if (this->javaVm->DetachCurrentThread() != JNI_OK) {
        LOGE("DetachCurrentThread failed!");
    }
}

結果展示

image.png

java回調(diào)接口

public interface CrashListener {
    void onCrash(String threadName, Error error);
}

使用方法

CrashUtils.init(CrashListener { threadName, error ->
            LogUtils.e("threadName:$threadName,error info : $error")
        })

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

Android平臺Native奔潰捕獲機制及實現(xiàn)

Android平臺Native奔潰捕獲機制及實現(xiàn)

前言

信號機制

捕捉信號量

設置額外的?？臻g

分析堆棧

將native信息拋給Java

結果展示

相關閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

Android平臺Native奔潰捕獲機制及實現(xiàn)

前言

信號機制

捕捉信號量

設置額外的?？臻g

分析堆棧

將native信息拋給Java

結果展示

相關閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

設置額外的?？臻g