Method setSoftBreakpointAndWait

KittyMemoryEx/KittyTrace.cpp:877–1077

}

KT_BP_RESULT KittyTraceMgr::setSoftBreakpointAndWait(uintptr_t address,
                                                     const std::function<bool(user_regs_struct regs)> &cb,
                                                     int timeout_ms)
{
    if (!_attached || _pid <= 0 || address == 0)
        return KT_BP_FAILED;

#if defined(__arm__)
    bool thumb = address & 1;
    if (thumb)
        address &= ~1;
    else
        address &= ~3UL;
#elif defined(__aarch64__)
    address &= ~3UL;
#endif

    pid_t tid = _pid;

    std::vector<uint8_t> brk_code(sizeof(uintptr_t), 0);
    std::vector<uint8_t> bak_code(sizeof(uintptr_t), 0);
    int status = 0;
    pid_t wp = 0;
    user_regs_struct regs = {};

    // cleanup failure return
    auto failure_return = [&](KT_BP_RESULT res = KT_BP_FAILED) -> KT_BP_RESULT {
        KITTY_LOGE("setSoftBreakpointAndWait(%p): Failed.", (void *)address);
        pokeMem(address, bak_code.data(), bak_code.size());
        return res;
    };

    auto validate_trap = [this](const user_regs_struct &regs, uintptr_t trap_addr) -> bool {
        uintptr_t pc = regs.KT_REG_PC;
        uintptr_t max_range = KT_ALIGN_UP(trap_addr + sizeof(KittyTraceInsns::BRKP), sizeof(uintptr_t));
        if (!(pc >= trap_addr && pc <= max_range))
        {
            siginfo_t si = {};
            getSignalInfo(&si);
            return uintptr_t(si.si_addr) >= trap_addr && uintptr_t(si.si_addr) <= max_range;
        }
        return true;
    };

again:
    wp = 0;
    status = 0;
    memset(&regs, 0, sizeof(regs));

    if (!peekMem(address, bak_code.data(), bak_code.size()))
    {
        KITTY_LOGE("setSoftBreakpointAndWait(%p): Failed to backup memory code.", (void *)address);
        return KT_BP_MEM_FAILED;
    }

#if defined(__arm__)
    if (thumb)
        memcpy(brk_code.data(), KittyTraceInsns::THUMB_BRKP, sizeof(KittyTraceInsns::THUMB_BRKP));