Lua调试工具使用及原理

前言

当我们在linux下使用c/c++开发时,可以通过gdb来调试我们编译后的elf文件。gdb支持了attch、单步运行(单行、单指令)、设置断点等非常实用的功能来辅助我们调试。当使用lua开发的时候,一般可能会使用print(打印到屏幕)或是输出日志等稍微简陋的调试方式,但如果日志输出不能满足我们需求时,比如我们需要类似断点、单步执行等更高级的调试功能,此时就必须借助第三方工具。
本文介绍了lua调试工具LuaPanda的使用,以及lua调试工具和gdb在实现上的一些区别。

gdb调试原理

先简单介绍一下gdb的原理。一般的我们将gdb这种调试进程称为tracer,被调试进程称为tracee。当进程被调试时(处于traced状态)时,每次收到任何除了SIGKILL以外的任何信号,都会暂停当前的执行,并且tracer进程可以通过waitpid来获取tracee的暂停原因。gdb使用ptrace系统调用来实现操作tracee进程

1. gdb附加到进程

当使用gdb附加到一个正在运行的进程(tracee)上时,gdb会执行类似下面的代码:

ptrace(PTRACE_ATTACH, pid, ...)

这里的pid是tracee的pid。系统调用执行后,os会给tracee进程发送一个SIGTRAP信号,然后tracee的执行将会暂停。最后gdb(tracer)可以通过系统调用waitpid来获取tracee的暂停原因,并且开始调试。

2. gdb单步执行

单步调试与上述attch类似,gdb通过下面的代码告诉tracee进程需要在运行完一个指令后暂停:

ptrace(PTRACE_SINGLESTEP, pid, ...)

当tracee执行完一个指令后,tracee也会因为收到os的SIGTRAP信号从而暂停执行。

3. gdb设置断点

设置断点稍微有点不同,首先gdb需要从调试程序的调试信息中根据行号(函数名)找到代码的内存地址,然后通过ptrace将tracee进程的代码替换成一个软中断指令:int 3。由于这个指令实际上会被编码为一个字节0xcc,因此可以很安全的与任何指令替换。

/* Look at the word at the address we're interested in */
unsigned addr = 0x8048096;
unsigned data = ptrace(PTRACE_PEEKTEXT, child_pid, (void*)addr, 0);

/* Write the trap instruction 'int 3' into the address */
unsigned data_with_trap = (data & 0xFFFFFF00) | 0xCC;
ptrace(PTRACE_POKETEXT, child_pid, (void*)addr, (void*)data_with_trap);

通过给ptrace指定PTRACE_PEEKTEXT、PTRACE_POKETEXT可以读写tracee进程的代码段的内存。最终当程序执行到int 3时,会触发一个软中断,os会给tracee进程发送SIGTRAP信号。当断点成功后,gdb会用相同的方法用原来的指令替换掉int 3,在这之后tracee就可以正常执行了。

LuaPanda使用介绍

LuaPanda是腾讯开源的一个lua调试工具,配合vscode可以做到类似gdb的调试功能。当开始调试时,vscode会监听本机(127.0.0.1)的8818端口。tracce进程(包含被调试的lua代码的进程)通过LuaPanda连上vscode:

require("LuaPanda").start("127.0.0.1",8818);

LuaPanda通过使用LuaSocket模块创建tcp连接以此来实现通信(对比gdb使用信号机制通信)。vscode会把用户的调式命令(如设置断点、continue、单步运行等)通过tcp发送给tracee进程。

Lua调试原理

lua调试与gdb不同,我们可以通过debug.sethook来为一个lua线程设置hook函数,在调用函数、离开函数、进入新行的时候lua会先执行这个hook函数。LuaPanda在连接上vscode后会注册一个hook函数:

debug.sethook(this.debug_hook, "lrc");

"lrc"字符串掩码决定了hook函数会在什么时候被调用:

  • 'c': 每当 Lua 调用一个函数时,调用钩子;
  • 'r': 每当 Lua 从一个函数内返回时,调用钩子;
  • 'l': 每当 Lua 进入新的一行时,调用钩子。

1. LuaPanda设置断点

当我们设置一个断点时,vscode会把断点的信息,包括文件路径、行号发给tracee进程。tracee收到setBreakPoint命令时,表示需要注册一个断点。此时LuaPanda会将断点的信息存储在一个全局的lua Table中:breaks。

-- 处理 收到的消息
-- @dataStr 接收的消息json
function this.dataProcess( dataStr )
    ...
    elseif dataTable.cmd == "setBreakPoint" then
        this.printToVSCode("dataTable.cmd == setBreakPoint");
        local bkPath = dataTable.info.path;
        bkPath = this.genUnifiedPath(bkPath);
        if autoPathMode then 
            -- 自动路径模式下,仅保留文件名
            bkPath = this.getFilenameFromPath(bkPath);
        end
        this.printToVSCode("setBreakPoint path:"..tostring(bkPath));
        breaks[bkPath] = dataTable.info.bks;

当lua虚拟机调用hook函数的时候,hook会遍历breaks,看一下当前行是否命中断点:

------------------------断点处理-------------------------
-- 参数info是当前堆栈信息
-- @info getInfo获取的当前调用信息
function this.isHitBreakpoint( info )
    local curLine = tostring(info.currentline);
    local breakpointPath = info.source;
    local isPathHit = false;
    
    if breaks[breakpointPath] then
        isPathHit = true;
    end

    if isPathHit then
        for k,v in ipairs(breaks[breakpointPath]) do
            if tostring(v["line"]) == tostring(curLine) then
                ...

如果断点被命中则会发一个消息给vscode,并原地等待消息回包,以此来实现暂停执行tracee进程:

function this.real_hook_process(info)
    ...
    local isHit = false;
    if tostring(event) == "line" and jumpFlag == false then
        if currentRunState == runState.RUN or currentRunState == runState.STEPOVER or currentRunState == runState.STEPIN or currentRunState == runState.STEPOUT then
            --断点判断
            isHit = this.isHitBreakpoint(info) or hitBP;
            if isHit == true then
                this.printToVSCode(" + HitBreakpoint true");
                hitBP = false; --hitBP是断点硬性命中标记
                --计数器清0
                stepOverCounter = 0;
                stepOutCounter = 0;
                this.changeRunState(runState.HIT_BREAKPOINT);
                --发消息并等待
                this.SendMsgWithStack("stopOnBreakpoint");

2. LuaPanda单步执行

单步执行实现比较简单,当tracee收到stopOnStep命令时,表示vscode需要单步执行代码:执行到新的一行需要暂停,并且当有函数调用时应该跳过函数。LuaPanda在处理setBreakPoint命令时操作非常简单:将运行状态改为runState.STEPOVER然后结束:

-- 处理 收到的消息
-- @dataStr 接收的消息json
function this.dataProcess( dataStr )
    ...
    elseif dataTable.cmd == "stopOnStep" then
        this.changeRunState(runState.STEPOVER);
        local msgTab = this.getMsgTable("stopOnStep", this.getCallbackId());
        this.sendMsg(msgTab);
        this.changeHookState(hookState.ALL_HOOK);

当lua虚拟机由于进入新行(event为"line")时执行hook函数时,会根据stepOverCounter计数器来决定这次是否要暂停执行。而stepOverCounter计数器会在调用函数的时候+1,离开函数的时候-1。因此当处于内部函数调用的时候,计数器的值会大于零,执行不会被暂停,从而实现跳过函数执行。

function this.real_hook_process(info)
    ...
    if currentRunState == runState.STEPOVER then
        -- line stepOverCounter!= 0 不作操作
        -- line stepOverCounter == 0 停止
        if event == "line" and stepOverCounter <= 0 and jumpFlag == false then
            stepOverCounter = 0;
            this.changeRunState(runState.STEPOVER_STOP)
            this.SendMsgWithStack("stopOnStep");
        elseif event == "return" or event == "tail return" then
            --5.1中是tail return
            if stepOverCounter ~= 0 then
                stepOverCounter = stepOverCounter - 1;
            end
        elseif event == "call" then
            stepOverCounter = stepOverCounter + 1;
        end

lua hook实现

下面是LuaState结构中的与hook函数有关的字段:

/*
** 'per thread' state
*/
struct lua_State {
  ...
  volatile lua_Hook hook;
  l_signalT hookmask;
  ...
};

其中,hook字段表示对应的函数地址,hookmask是一个掩码,表示需要调用hook函数的事件。

lua虚拟机会在每次执行每一个字节码之前判断是否需要调用hook函数。lua虚拟机执行的主循环(luaV_execute函数中),每次通过vmfetch获取一个字节码指令时,都会先检查LuaState的hookmask字段,看是否有LUA_MASKLINE标记,若有则继续判断是否进入新行。

void luaV_execute (lua_State *L) {
    ...
    /* main loop of interpreter */
  for (;;) {
    Instruction i;
    StkId ra;
    vmfetch();
    ...

vmfetch是一个宏,定义为:

/* fetch an instruction and prepare its execution */
#define vmfetch()	{ \
  i = *(ci->u.l.savedpc++); \
  if (L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) \
    Protect(luaG_traceexec(L)); \
  ra = RA(i); /* WARNING: any stack reallocation invalidates 'ra' */ \
  lua_assert(base == ci->u.l.base); \
  lua_assert(base <= L->top && L->top < L->stack + L->stacksize); \
}

最后在函数luaG_traceexec中判断是否执行新行:

void luaG_traceexec (lua_State *L) {
    ...
    if (mask & LUA_MASKLINE) {
    Proto *p = ci_func(ci)->p;
    int npc = pcRel(ci->u.l.savedpc, p);
    int newline = getfuncline(p, npc);
    if (npc == 0 ||  /* call linehook when enter a new function, */
        ci->u.l.savedpc <= L->oldpc ||  /* when jump back (loop), or when */
        newline != getfuncline(p, pcRel(L->oldpc, p)))  /* enter a new line */
      luaD_hook(L, LUA_HOOKLINE, newline);  /* call line hook */
  }

从代码可以看到在lua中,通过debug.sethook注册hook函数是有性能损耗的:

  1. 每次执行字节码前都需要判断是否是新行;
  2. 每次执行新行前都需要调用一个lua的函数(hook函数)

而且LuaPanda的实现上看,断点命中判断是遍历breaks做字符串匹配,所以效率较低,不推荐在生产环境下使用LuaPanda调试(即使没有设置断点)。也不推荐在生产环境注册hook函数。

LuaPanda使用限制

由于LuaPanda是使用debug.sethook来实现调试功能的,并且由于每个luaState只能注册一个hook函数。因此如果在代码的其它地方中注册hook函数就会把LuaPanda的hook给覆盖。
因此在调试时不能运行luacov这类的工具,因为luacov内部也会通过debug.sethook来注册钩子函数。

posted @ 2020-07-12 17:10  adinosaur  阅读(298)  评论(0编辑  收藏